import '@polkadot/api-base/types/events';
import type { ApiTypes, AugmentedEvent } from '@polkadot/api-base/types';
import type { Bytes, Null, Option, Result, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
import type { ITuple } from '@polkadot/types-codec/types';
import type { EthereumAddress } from '@polkadot/types/interfaces/eth';
import type { AccountId32, H256, Perbill } from '@polkadot/types/interfaces/runtime';
import type { FrameSupportDispatchPostDispatchInfo, FrameSupportMessagesProcessMessageError, FrameSupportPreimagesBounded, FrameSupportTokensMiscBalanceStatus, FrameSystemDispatchEventInfo, PalletBalancesUnexpectedKind, PalletConvictionVotingTally, PalletConvictionVotingVoteAccountVote, PalletElectionProviderMultiPhaseElectionCompute, PalletElectionProviderMultiPhasePhase, PalletMultisigTimepoint, PalletNominationPoolsClaimPermission, PalletNominationPoolsCommissionChangeRate, PalletNominationPoolsCommissionClaimPermission, PalletNominationPoolsPoolState, PalletProxyDepositKind, PalletRcMigratorMigrationSettings, PalletRcMigratorMigrationStage, PalletRcMigratorQueuePriority, PalletStakingAsyncAhClientUnexpectedKind, PalletStakingForcing, PalletStakingRewardDestination, PalletStakingValidatorPrefs, PalletStateTrieMigrationError, PalletStateTrieMigrationMigrationCompute, PolkadotParachainPrimitivesPrimitivesHrmpChannelId, PolkadotPrimitivesVstagingCandidateReceiptV2, PolkadotRuntimeCommonImplsVersionedLocatableAsset, PolkadotRuntimeConstantsProxyProxyType, PolkadotRuntimeParachainsDisputesDisputeLocation, PolkadotRuntimeParachainsDisputesDisputeResult, PolkadotRuntimeParachainsInclusionAggregateMessageOrigin, SpConsensusGrandpaAppPublic, SpNposElectionsElectionScore, SpRuntimeDispatchError, SpRuntimeDispatchErrorWithPostInfo, SpWeightsWeightV2Weight, StagingXcmV5AssetAssets, StagingXcmV5Location, StagingXcmV5Response, StagingXcmV5TraitsOutcome, StagingXcmV5Xcm, XcmV3MaybeErrorCode, XcmV3TraitsSendError, XcmV5TraitsError, XcmVersionedAssets, XcmVersionedLocation } from '@polkadot/types/lookup';
export type __AugmentedEvent<ApiType extends ApiTypes> = AugmentedEvent<ApiType>;
declare module '@polkadot/api-base/types/events' {
    interface AugmentedEvents<ApiType extends ApiTypes> {
        assetRate: {
            AssetRateCreated: AugmentedEvent<ApiType, [assetKind: PolkadotRuntimeCommonImplsVersionedLocatableAsset, rate: u128], {
                assetKind: PolkadotRuntimeCommonImplsVersionedLocatableAsset;
                rate: u128;
            }>;
            AssetRateRemoved: AugmentedEvent<ApiType, [assetKind: PolkadotRuntimeCommonImplsVersionedLocatableAsset], {
                assetKind: PolkadotRuntimeCommonImplsVersionedLocatableAsset;
            }>;
            AssetRateUpdated: AugmentedEvent<ApiType, [assetKind: PolkadotRuntimeCommonImplsVersionedLocatableAsset, old: u128, new_: u128], {
                assetKind: PolkadotRuntimeCommonImplsVersionedLocatableAsset;
                old: u128;
                new_: u128;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        auctions: {
            /**
             * An auction ended. All funds become unreserved.
             **/
            AuctionClosed: AugmentedEvent<ApiType, [auctionIndex: u32], {
                auctionIndex: u32;
            }>;
            /**
             * An auction started. Provides its index and the block number where it will begin to
             * close and the first lease period of the quadruplet that is auctioned.
             **/
            AuctionStarted: AugmentedEvent<ApiType, [auctionIndex: u32, leasePeriod: u32, ending: u32], {
                auctionIndex: u32;
                leasePeriod: u32;
                ending: u32;
            }>;
            /**
             * A new bid has been accepted as the current winner.
             **/
            BidAccepted: AugmentedEvent<ApiType, [bidder: AccountId32, paraId: u32, amount: u128, firstSlot: u32, lastSlot: u32], {
                bidder: AccountId32;
                paraId: u32;
                amount: u128;
                firstSlot: u32;
                lastSlot: u32;
            }>;
            /**
             * Someone attempted to lease the same slot twice for a parachain. The amount is held in
             * reserve but no parachain slot has been leased.
             **/
            ReserveConfiscated: AugmentedEvent<ApiType, [paraId: u32, leaser: AccountId32, amount: u128], {
                paraId: u32;
                leaser: AccountId32;
                amount: u128;
            }>;
            /**
             * Funds were reserved for a winning bid. First balance is the extra amount reserved.
             * Second is the total.
             **/
            Reserved: AugmentedEvent<ApiType, [bidder: AccountId32, extraReserved: u128, totalAmount: u128], {
                bidder: AccountId32;
                extraReserved: u128;
                totalAmount: u128;
            }>;
            /**
             * Funds were unreserved since bidder is no longer active. `[bidder, amount]`
             **/
            Unreserved: AugmentedEvent<ApiType, [bidder: AccountId32, amount: u128], {
                bidder: AccountId32;
                amount: u128;
            }>;
            /**
             * The winning offset was chosen for an auction. This will map into the `Winning` storage
             * map.
             **/
            WinningOffset: AugmentedEvent<ApiType, [auctionIndex: u32, blockNumber: u32], {
                auctionIndex: u32;
                blockNumber: u32;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        balances: {
            /**
             * A balance was set by root.
             **/
            BalanceSet: AugmentedEvent<ApiType, [who: AccountId32, free: u128], {
                who: AccountId32;
                free: u128;
            }>;
            /**
             * Some amount was burned from an account.
             **/
            Burned: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: 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 frozen.
             **/
            Frozen: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * Total issuance was increased by `amount`, creating a credit to be balanced.
             **/
            Issued: AugmentedEvent<ApiType, [amount: u128], {
                amount: u128;
            }>;
            /**
             * Some balance was locked.
             **/
            Locked: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * Some amount was minted into an account.
             **/
            Minted: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * Total issuance was decreased by `amount`, creating a debt to be balanced.
             **/
            Rescinded: AugmentedEvent<ApiType, [amount: u128], {
                amount: 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 restored into an account.
             **/
            Restored: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * Some amount was removed from the account (e.g. for misbehavior).
             **/
            Slashed: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * Some amount was suspended from an account (it can be restored later).
             **/
            Suspended: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * Some balance was thawed.
             **/
            Thawed: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * The `TotalIssuance` was forcefully changed.
             **/
            TotalIssuanceForced: AugmentedEvent<ApiType, [old: u128, new_: u128], {
                old: u128;
                new_: u128;
            }>;
            /**
             * Transfer succeeded.
             **/
            Transfer: AugmentedEvent<ApiType, [from: AccountId32, to: AccountId32, amount: u128], {
                from: AccountId32;
                to: AccountId32;
                amount: u128;
            }>;
            /**
             * An unexpected/defensive event was triggered.
             **/
            Unexpected: AugmentedEvent<ApiType, [PalletBalancesUnexpectedKind]>;
            /**
             * Some balance was unlocked.
             **/
            Unlocked: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * Some balance was unreserved (moved from reserved to free).
             **/
            Unreserved: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * An account was upgraded.
             **/
            Upgraded: AugmentedEvent<ApiType, [who: AccountId32], {
                who: AccountId32;
            }>;
            /**
             * Some amount was withdrawn from the account (e.g. for transaction fees).
             **/
            Withdraw: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        bounties: {
            /**
             * A bounty is approved.
             **/
            BountyApproved: AugmentedEvent<ApiType, [index: u32], {
                index: u32;
            }>;
            /**
             * A bounty is awarded to a beneficiary.
             **/
            BountyAwarded: AugmentedEvent<ApiType, [index: u32, beneficiary: AccountId32], {
                index: u32;
                beneficiary: AccountId32;
            }>;
            /**
             * A bounty proposal is funded and became active.
             **/
            BountyBecameActive: AugmentedEvent<ApiType, [index: u32], {
                index: u32;
            }>;
            /**
             * A bounty is cancelled.
             **/
            BountyCanceled: AugmentedEvent<ApiType, [index: u32], {
                index: u32;
            }>;
            /**
             * A bounty is claimed by beneficiary.
             **/
            BountyClaimed: AugmentedEvent<ApiType, [index: u32, payout: u128, beneficiary: AccountId32], {
                index: u32;
                payout: u128;
                beneficiary: AccountId32;
            }>;
            /**
             * A bounty expiry is extended.
             **/
            BountyExtended: AugmentedEvent<ApiType, [index: u32], {
                index: u32;
            }>;
            /**
             * New bounty proposal.
             **/
            BountyProposed: AugmentedEvent<ApiType, [index: u32], {
                index: u32;
            }>;
            /**
             * A bounty proposal was rejected; funds were slashed.
             **/
            BountyRejected: AugmentedEvent<ApiType, [index: u32, bond: u128], {
                index: u32;
                bond: u128;
            }>;
            /**
             * A bounty curator is accepted.
             **/
            CuratorAccepted: AugmentedEvent<ApiType, [bountyId: u32, curator: AccountId32], {
                bountyId: u32;
                curator: AccountId32;
            }>;
            /**
             * A bounty curator is proposed.
             **/
            CuratorProposed: AugmentedEvent<ApiType, [bountyId: u32, curator: AccountId32], {
                bountyId: u32;
                curator: AccountId32;
            }>;
            /**
             * A bounty curator is unassigned.
             **/
            CuratorUnassigned: AugmentedEvent<ApiType, [bountyId: u32], {
                bountyId: u32;
            }>;
            /**
             * A bounty deposit has been poked.
             **/
            DepositPoked: AugmentedEvent<ApiType, [bountyId: u32, proposer: AccountId32, oldDeposit: u128, newDeposit: u128], {
                bountyId: u32;
                proposer: AccountId32;
                oldDeposit: u128;
                newDeposit: u128;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        childBounties: {
            /**
             * A child-bounty is added.
             **/
            Added: AugmentedEvent<ApiType, [index: u32, childIndex: u32], {
                index: u32;
                childIndex: u32;
            }>;
            /**
             * A child-bounty is awarded to a beneficiary.
             **/
            Awarded: AugmentedEvent<ApiType, [index: u32, childIndex: u32, beneficiary: AccountId32], {
                index: u32;
                childIndex: u32;
                beneficiary: AccountId32;
            }>;
            /**
             * A child-bounty is cancelled.
             **/
            Canceled: AugmentedEvent<ApiType, [index: u32, childIndex: u32], {
                index: u32;
                childIndex: u32;
            }>;
            /**
             * A child-bounty is claimed by beneficiary.
             **/
            Claimed: AugmentedEvent<ApiType, [index: u32, childIndex: u32, payout: u128, beneficiary: AccountId32], {
                index: u32;
                childIndex: u32;
                payout: u128;
                beneficiary: AccountId32;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        claims: {
            /**
             * Someone claimed some DOTs.
             **/
            Claimed: AugmentedEvent<ApiType, [who: AccountId32, ethereumAddress: EthereumAddress, amount: u128], {
                who: AccountId32;
                ethereumAddress: EthereumAddress;
                amount: u128;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        convictionVoting: {
            /**
             * An account has delegated their vote to another account. \[who, target\]
             **/
            Delegated: AugmentedEvent<ApiType, [AccountId32, AccountId32]>;
            /**
             * An \[account\] has cancelled a previous delegation operation.
             **/
            Undelegated: AugmentedEvent<ApiType, [AccountId32]>;
            /**
             * An account has voted
             **/
            Voted: AugmentedEvent<ApiType, [who: AccountId32, vote: PalletConvictionVotingVoteAccountVote], {
                who: AccountId32;
                vote: PalletConvictionVotingVoteAccountVote;
            }>;
            /**
             * A vote has been removed
             **/
            VoteRemoved: AugmentedEvent<ApiType, [who: AccountId32, vote: PalletConvictionVotingVoteAccountVote], {
                who: AccountId32;
                vote: PalletConvictionVotingVoteAccountVote;
            }>;
            /**
             * The lockup period of a conviction vote expired, and the funds have been unlocked.
             **/
            VoteUnlocked: AugmentedEvent<ApiType, [who: AccountId32, class_: u16], {
                who: AccountId32;
                class: u16;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        coretime: {
            /**
             * A core has received a new assignment from the broker chain.
             **/
            CoreAssigned: AugmentedEvent<ApiType, [core: u32], {
                core: u32;
            }>;
            /**
             * The broker chain has asked for revenue information for a specific block.
             **/
            RevenueInfoRequested: AugmentedEvent<ApiType, [when: u32], {
                when: u32;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        crowdloan: {
            /**
             * A parachain has been moved to `NewRaise`
             **/
            AddedToNewRaise: AugmentedEvent<ApiType, [paraId: u32], {
                paraId: u32;
            }>;
            /**
             * All loans in a fund have been refunded.
             **/
            AllRefunded: AugmentedEvent<ApiType, [paraId: u32], {
                paraId: u32;
            }>;
            /**
             * Contributed to a crowd sale.
             **/
            Contributed: AugmentedEvent<ApiType, [who: AccountId32, fundIndex: u32, amount: u128], {
                who: AccountId32;
                fundIndex: u32;
                amount: u128;
            }>;
            /**
             * Create a new crowdloaning campaign.
             **/
            Created: AugmentedEvent<ApiType, [paraId: u32], {
                paraId: u32;
            }>;
            /**
             * Fund is dissolved.
             **/
            Dissolved: AugmentedEvent<ApiType, [paraId: u32], {
                paraId: u32;
            }>;
            /**
             * The configuration to a crowdloan has been edited.
             **/
            Edited: AugmentedEvent<ApiType, [paraId: u32], {
                paraId: u32;
            }>;
            /**
             * The result of trying to submit a new bid to the Slots pallet.
             **/
            HandleBidResult: AugmentedEvent<ApiType, [paraId: u32, result: Result<Null, SpRuntimeDispatchError>], {
                paraId: u32;
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * A memo has been updated.
             **/
            MemoUpdated: AugmentedEvent<ApiType, [who: AccountId32, paraId: u32, memo: Bytes], {
                who: AccountId32;
                paraId: u32;
                memo: Bytes;
            }>;
            /**
             * The loans in a fund have been partially dissolved, i.e. there are some left
             * over child keys that still need to be killed.
             **/
            PartiallyRefunded: AugmentedEvent<ApiType, [paraId: u32], {
                paraId: u32;
            }>;
            /**
             * Withdrew full balance of a contributor.
             **/
            Withdrew: AugmentedEvent<ApiType, [who: AccountId32, fundIndex: u32, amount: u128], {
                who: AccountId32;
                fundIndex: u32;
                amount: u128;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        delegatedStaking: {
            /**
             * Funds delegated by a delegator.
             **/
            Delegated: AugmentedEvent<ApiType, [agent: AccountId32, delegator: AccountId32, amount: u128], {
                agent: AccountId32;
                delegator: AccountId32;
                amount: u128;
            }>;
            /**
             * Unclaimed delegation funds migrated to delegator.
             **/
            MigratedDelegation: AugmentedEvent<ApiType, [agent: AccountId32, delegator: AccountId32, amount: u128], {
                agent: AccountId32;
                delegator: AccountId32;
                amount: u128;
            }>;
            /**
             * Funds released to a delegator.
             **/
            Released: AugmentedEvent<ApiType, [agent: AccountId32, delegator: AccountId32, amount: u128], {
                agent: AccountId32;
                delegator: AccountId32;
                amount: u128;
            }>;
            /**
             * Funds slashed from a delegator.
             **/
            Slashed: AugmentedEvent<ApiType, [agent: AccountId32, delegator: AccountId32, amount: u128], {
                agent: AccountId32;
                delegator: AccountId32;
                amount: u128;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        electionProviderMultiPhase: {
            /**
             * An election failed.
             *
             * Not much can be said about which computes failed in the process.
             **/
            ElectionFailed: AugmentedEvent<ApiType, []>;
            /**
             * The election has been finalized, with the given computation and score.
             **/
            ElectionFinalized: AugmentedEvent<ApiType, [compute: PalletElectionProviderMultiPhaseElectionCompute, score: SpNposElectionsElectionScore], {
                compute: PalletElectionProviderMultiPhaseElectionCompute;
                score: SpNposElectionsElectionScore;
            }>;
            /**
             * There was a phase transition in a given round.
             **/
            PhaseTransitioned: AugmentedEvent<ApiType, [from: PalletElectionProviderMultiPhasePhase, to: PalletElectionProviderMultiPhasePhase, round: u32], {
                from: PalletElectionProviderMultiPhasePhase;
                to: PalletElectionProviderMultiPhasePhase;
                round: u32;
            }>;
            /**
             * An account has been rewarded for their signed submission being finalized.
             **/
            Rewarded: AugmentedEvent<ApiType, [account: AccountId32, value: u128], {
                account: AccountId32;
                value: u128;
            }>;
            /**
             * An account has been slashed for submitting an invalid signed submission.
             **/
            Slashed: AugmentedEvent<ApiType, [account: AccountId32, value: u128], {
                account: AccountId32;
                value: u128;
            }>;
            /**
             * A solution was stored with the given compute.
             *
             * The `origin` indicates the origin of the solution. If `origin` is `Some(AccountId)`,
             * the stored solution was submitted in the signed phase by a miner with the `AccountId`.
             * Otherwise, the solution was stored either during the unsigned phase or by
             * `T::ForceOrigin`. The `bool` is `true` when a previous solution was ejected to make
             * room for this one.
             **/
            SolutionStored: AugmentedEvent<ApiType, [compute: PalletElectionProviderMultiPhaseElectionCompute, origin: Option<AccountId32>, prevEjected: bool], {
                compute: PalletElectionProviderMultiPhaseElectionCompute;
                origin: Option<AccountId32>;
                prevEjected: bool;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        fastUnstake: {
            /**
             * A batch was partially checked for the given eras, but the process did not finish.
             **/
            BatchChecked: AugmentedEvent<ApiType, [eras: Vec<u32>], {
                eras: Vec<u32>;
            }>;
            /**
             * A batch of a given size was terminated.
             *
             * This is always follows by a number of `Unstaked` or `Slashed` events, marking the end
             * of the batch. A new batch will be created upon next block.
             **/
            BatchFinished: AugmentedEvent<ApiType, [size_: u32], {
                size_: u32;
            }>;
            /**
             * An internal error happened. Operations will be paused now.
             **/
            InternalError: AugmentedEvent<ApiType, []>;
            /**
             * A staker was slashed for requesting fast-unstake whilst being exposed.
             **/
            Slashed: AugmentedEvent<ApiType, [stash: AccountId32, amount: u128], {
                stash: AccountId32;
                amount: u128;
            }>;
            /**
             * A staker was unstaked.
             **/
            Unstaked: AugmentedEvent<ApiType, [stash: AccountId32, result: Result<Null, SpRuntimeDispatchError>], {
                stash: AccountId32;
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        grandpa: {
            /**
             * New authority set has been applied.
             **/
            NewAuthorities: AugmentedEvent<ApiType, [authoritySet: Vec<ITuple<[SpConsensusGrandpaAppPublic, u64]>>], {
                authoritySet: Vec<ITuple<[SpConsensusGrandpaAppPublic, u64]>>;
            }>;
            /**
             * Current authority set has been paused.
             **/
            Paused: AugmentedEvent<ApiType, []>;
            /**
             * Current authority set has been resumed.
             **/
            Resumed: AugmentedEvent<ApiType, []>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        historical: {
            /**
             * The merkle roots of up to this session index were pruned
             **/
            RootsPruned: AugmentedEvent<ApiType, [upTo: u32], {
                upTo: u32;
            }>;
            /**
             * The merkle root of the validators of the said session were stored
             **/
            RootStored: AugmentedEvent<ApiType, [index: u32], {
                index: u32;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        hrmp: {
            /**
             * HRMP channel closed.
             **/
            ChannelClosed: AugmentedEvent<ApiType, [byParachain: u32, channelId: PolkadotParachainPrimitivesPrimitivesHrmpChannelId], {
                byParachain: u32;
                channelId: PolkadotParachainPrimitivesPrimitivesHrmpChannelId;
            }>;
            /**
             * An HRMP channel was opened via Root origin.
             **/
            HrmpChannelForceOpened: AugmentedEvent<ApiType, [sender: u32, recipient: u32, proposedMaxCapacity: u32, proposedMaxMessageSize: u32], {
                sender: u32;
                recipient: u32;
                proposedMaxCapacity: u32;
                proposedMaxMessageSize: u32;
            }>;
            /**
             * An HRMP channel was opened with a system chain.
             **/
            HrmpSystemChannelOpened: AugmentedEvent<ApiType, [sender: u32, recipient: u32, proposedMaxCapacity: u32, proposedMaxMessageSize: u32], {
                sender: u32;
                recipient: u32;
                proposedMaxCapacity: u32;
                proposedMaxMessageSize: u32;
            }>;
            /**
             * Open HRMP channel accepted.
             **/
            OpenChannelAccepted: AugmentedEvent<ApiType, [sender: u32, recipient: u32], {
                sender: u32;
                recipient: u32;
            }>;
            /**
             * An HRMP channel request sent by the receiver was canceled by either party.
             **/
            OpenChannelCanceled: AugmentedEvent<ApiType, [byParachain: u32, channelId: PolkadotParachainPrimitivesPrimitivesHrmpChannelId], {
                byParachain: u32;
                channelId: PolkadotParachainPrimitivesPrimitivesHrmpChannelId;
            }>;
            /**
             * An HRMP channel's deposits were updated.
             **/
            OpenChannelDepositsUpdated: AugmentedEvent<ApiType, [sender: u32, recipient: u32], {
                sender: u32;
                recipient: u32;
            }>;
            /**
             * Open HRMP channel requested.
             **/
            OpenChannelRequested: AugmentedEvent<ApiType, [sender: u32, recipient: u32, proposedMaxCapacity: u32, proposedMaxMessageSize: u32], {
                sender: u32;
                recipient: u32;
                proposedMaxCapacity: u32;
                proposedMaxMessageSize: u32;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        indices: {
            /**
             * A deposit to reserve an index has been poked/reconsidered.
             **/
            DepositPoked: AugmentedEvent<ApiType, [who: AccountId32, index: u32, oldDeposit: u128, newDeposit: u128], {
                who: AccountId32;
                index: u32;
                oldDeposit: u128;
                newDeposit: u128;
            }>;
            /**
             * A account index was assigned.
             **/
            IndexAssigned: AugmentedEvent<ApiType, [who: AccountId32, index: u32], {
                who: AccountId32;
                index: u32;
            }>;
            /**
             * A account index has been freed up (unassigned).
             **/
            IndexFreed: AugmentedEvent<ApiType, [index: u32], {
                index: u32;
            }>;
            /**
             * A account index has been frozen to its current account ID.
             **/
            IndexFrozen: AugmentedEvent<ApiType, [index: u32, who: AccountId32], {
                index: u32;
                who: AccountId32;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        messageQueue: {
            /**
             * Message placed in overweight queue.
             **/
            OverweightEnqueued: AugmentedEvent<ApiType, [id: U8aFixed, origin: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin, pageIndex: u32, messageIndex: u32], {
                id: U8aFixed;
                origin: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin;
                pageIndex: u32;
                messageIndex: u32;
            }>;
            /**
             * This page was reaped.
             **/
            PageReaped: AugmentedEvent<ApiType, [origin: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin, index: u32], {
                origin: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin;
                index: u32;
            }>;
            /**
             * Message is processed.
             **/
            Processed: AugmentedEvent<ApiType, [id: H256, origin: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin, weightUsed: SpWeightsWeightV2Weight, success: bool], {
                id: H256;
                origin: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin;
                weightUsed: SpWeightsWeightV2Weight;
                success: bool;
            }>;
            /**
             * Message discarded due to an error in the `MessageProcessor` (usually a format error).
             **/
            ProcessingFailed: AugmentedEvent<ApiType, [id: H256, origin: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin, error: FrameSupportMessagesProcessMessageError], {
                id: H256;
                origin: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin;
                error: FrameSupportMessagesProcessMessageError;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        multisig: {
            /**
             * The deposit for a multisig operation has been updated/poked.
             **/
            DepositPoked: AugmentedEvent<ApiType, [who: AccountId32, callHash: U8aFixed, oldDeposit: u128, newDeposit: u128], {
                who: AccountId32;
                callHash: U8aFixed;
                oldDeposit: u128;
                newDeposit: u128;
            }>;
            /**
             * A multisig operation has been approved by someone.
             **/
            MultisigApproval: AugmentedEvent<ApiType, [approving: AccountId32, timepoint: PalletMultisigTimepoint, multisig: AccountId32, callHash: U8aFixed], {
                approving: AccountId32;
                timepoint: PalletMultisigTimepoint;
                multisig: AccountId32;
                callHash: U8aFixed;
            }>;
            /**
             * A multisig operation has been cancelled.
             **/
            MultisigCancelled: AugmentedEvent<ApiType, [cancelling: AccountId32, timepoint: PalletMultisigTimepoint, multisig: AccountId32, callHash: U8aFixed], {
                cancelling: AccountId32;
                timepoint: PalletMultisigTimepoint;
                multisig: AccountId32;
                callHash: U8aFixed;
            }>;
            /**
             * A multisig operation has been executed.
             **/
            MultisigExecuted: AugmentedEvent<ApiType, [approving: AccountId32, timepoint: PalletMultisigTimepoint, multisig: AccountId32, callHash: U8aFixed, result: Result<Null, SpRuntimeDispatchError>], {
                approving: AccountId32;
                timepoint: PalletMultisigTimepoint;
                multisig: AccountId32;
                callHash: U8aFixed;
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * A new multisig operation has begun.
             **/
            NewMultisig: AugmentedEvent<ApiType, [approving: AccountId32, multisig: AccountId32, callHash: U8aFixed], {
                approving: AccountId32;
                multisig: AccountId32;
                callHash: U8aFixed;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        nominationPools: {
            /**
             * A member has became bonded in a pool.
             **/
            Bonded: AugmentedEvent<ApiType, [member: AccountId32, poolId: u32, bonded: u128, joined: bool], {
                member: AccountId32;
                poolId: u32;
                bonded: u128;
                joined: bool;
            }>;
            /**
             * A pool has been created.
             **/
            Created: AugmentedEvent<ApiType, [depositor: AccountId32, poolId: u32], {
                depositor: AccountId32;
                poolId: u32;
            }>;
            /**
             * A pool has been destroyed.
             **/
            Destroyed: AugmentedEvent<ApiType, [poolId: u32], {
                poolId: u32;
            }>;
            /**
             * Global parameters regulating nomination pools have been updated.
             **/
            GlobalParamsUpdated: AugmentedEvent<ApiType, [minJoinBond: u128, minCreateBond: u128, maxPools: Option<u32>, maxMembers: Option<u32>, maxMembersPerPool: Option<u32>, globalMaxCommission: Option<Perbill>], {
                minJoinBond: u128;
                minCreateBond: u128;
                maxPools: Option<u32>;
                maxMembers: Option<u32>;
                maxMembersPerPool: Option<u32>;
                globalMaxCommission: Option<Perbill>;
            }>;
            /**
             * A pool member's claim permission has been updated.
             **/
            MemberClaimPermissionUpdated: AugmentedEvent<ApiType, [member: AccountId32, permission: PalletNominationPoolsClaimPermission], {
                member: AccountId32;
                permission: PalletNominationPoolsClaimPermission;
            }>;
            /**
             * A member has been removed from a pool.
             *
             * The removal can be voluntary (withdrawn all unbonded funds) or involuntary (kicked).
             * Any funds that are still delegated (i.e. dangling delegation) are released and are
             * represented by `released_balance`.
             **/
            MemberRemoved: AugmentedEvent<ApiType, [poolId: u32, member: AccountId32, releasedBalance: u128], {
                poolId: u32;
                member: AccountId32;
                releasedBalance: u128;
            }>;
            /**
             * A pool's metadata was updated.
             **/
            MetadataUpdated: AugmentedEvent<ApiType, [poolId: u32, caller: AccountId32], {
                poolId: u32;
                caller: AccountId32;
            }>;
            /**
             * Topped up deficit in frozen ED of the reward pool.
             **/
            MinBalanceDeficitAdjusted: AugmentedEvent<ApiType, [poolId: u32, amount: u128], {
                poolId: u32;
                amount: u128;
            }>;
            /**
             * Claimed excess frozen ED of af the reward pool.
             **/
            MinBalanceExcessAdjusted: AugmentedEvent<ApiType, [poolId: u32, amount: u128], {
                poolId: u32;
                amount: u128;
            }>;
            /**
             * A payout has been made to a member.
             **/
            PaidOut: AugmentedEvent<ApiType, [member: AccountId32, poolId: u32, payout: u128], {
                member: AccountId32;
                poolId: u32;
                payout: u128;
            }>;
            /**
             * A pool's commission `change_rate` has been changed.
             **/
            PoolCommissionChangeRateUpdated: AugmentedEvent<ApiType, [poolId: u32, changeRate: PalletNominationPoolsCommissionChangeRate], {
                poolId: u32;
                changeRate: PalletNominationPoolsCommissionChangeRate;
            }>;
            /**
             * Pool commission has been claimed.
             **/
            PoolCommissionClaimed: AugmentedEvent<ApiType, [poolId: u32, commission: u128], {
                poolId: u32;
                commission: u128;
            }>;
            /**
             * Pool commission claim permission has been updated.
             **/
            PoolCommissionClaimPermissionUpdated: AugmentedEvent<ApiType, [poolId: u32, permission: Option<PalletNominationPoolsCommissionClaimPermission>], {
                poolId: u32;
                permission: Option<PalletNominationPoolsCommissionClaimPermission>;
            }>;
            /**
             * A pool's commission setting has been changed.
             **/
            PoolCommissionUpdated: AugmentedEvent<ApiType, [poolId: u32, current: Option<ITuple<[Perbill, AccountId32]>>], {
                poolId: u32;
                current: Option<ITuple<[Perbill, AccountId32]>>;
            }>;
            /**
             * A pool's maximum commission setting has been changed.
             **/
            PoolMaxCommissionUpdated: AugmentedEvent<ApiType, [poolId: u32, maxCommission: Perbill], {
                poolId: u32;
                maxCommission: Perbill;
            }>;
            /**
             * A pool's nominating account (or the pool's root account) has nominated a validator set
             * on behalf of the pool.
             **/
            PoolNominationMade: AugmentedEvent<ApiType, [poolId: u32, caller: AccountId32], {
                poolId: u32;
                caller: AccountId32;
            }>;
            /**
             * The pool is chilled i.e. no longer nominating.
             **/
            PoolNominatorChilled: AugmentedEvent<ApiType, [poolId: u32, caller: AccountId32], {
                poolId: u32;
                caller: AccountId32;
            }>;
            /**
             * The active balance of pool `pool_id` has been slashed to `balance`.
             **/
            PoolSlashed: AugmentedEvent<ApiType, [poolId: u32, balance: u128], {
                poolId: u32;
                balance: u128;
            }>;
            /**
             * The roles of a pool have been updated to the given new roles. Note that the depositor
             * can never change.
             **/
            RolesUpdated: AugmentedEvent<ApiType, [root: Option<AccountId32>, bouncer: Option<AccountId32>, nominator: Option<AccountId32>], {
                root: Option<AccountId32>;
                bouncer: Option<AccountId32>;
                nominator: Option<AccountId32>;
            }>;
            /**
             * The state of a pool has changed
             **/
            StateChanged: AugmentedEvent<ApiType, [poolId: u32, newState: PalletNominationPoolsPoolState], {
                poolId: u32;
                newState: PalletNominationPoolsPoolState;
            }>;
            /**
             * A member has unbonded from their pool.
             *
             * - `balance` is the corresponding balance of the number of points that has been
             * requested to be unbonded (the argument of the `unbond` transaction) from the bonded
             * pool.
             * - `points` is the number of points that are issued as a result of `balance` being
             * dissolved into the corresponding unbonding pool.
             * - `era` is the era in which the balance will be unbonded.
             * In the absence of slashing, these values will match. In the presence of slashing, the
             * number of points that are issued in the unbonding pool will be less than the amount
             * requested to be unbonded.
             **/
            Unbonded: AugmentedEvent<ApiType, [member: AccountId32, poolId: u32, balance: u128, points: u128, era: u32], {
                member: AccountId32;
                poolId: u32;
                balance: u128;
                points: u128;
                era: u32;
            }>;
            /**
             * The unbond pool at `era` of pool `pool_id` has been slashed to `balance`.
             **/
            UnbondingPoolSlashed: AugmentedEvent<ApiType, [poolId: u32, era: u32, balance: u128], {
                poolId: u32;
                era: u32;
                balance: u128;
            }>;
            /**
             * A member has withdrawn from their pool.
             *
             * The given number of `points` have been dissolved in return of `balance`.
             *
             * Similar to `Unbonded` event, in the absence of slashing, the ratio of point to balance
             * will be 1.
             **/
            Withdrawn: AugmentedEvent<ApiType, [member: AccountId32, poolId: u32, balance: u128, points: u128], {
                member: AccountId32;
                poolId: u32;
                balance: u128;
                points: u128;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        offences: {
            /**
             * There is an offence reported of the given `kind` happened at the `session_index` and
             * (kind-specific) time slot. This event is not deposited for duplicate slashes.
             * \[kind, timeslot\].
             **/
            Offence: AugmentedEvent<ApiType, [kind: U8aFixed, timeslot: Bytes], {
                kind: U8aFixed;
                timeslot: Bytes;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        onDemand: {
            /**
             * An account was given credits.
             **/
            AccountCredited: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * An order was placed at some spot price amount by orderer ordered_by
             **/
            OnDemandOrderPlaced: AugmentedEvent<ApiType, [paraId: u32, spotPrice: u128, orderedBy: AccountId32], {
                paraId: u32;
                spotPrice: u128;
                orderedBy: AccountId32;
            }>;
            /**
             * The value of the spot price has likely changed
             **/
            SpotPriceSet: AugmentedEvent<ApiType, [spotPrice: u128], {
                spotPrice: u128;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        paraInclusion: {
            /**
             * A candidate was backed. `[candidate, head_data]`
             **/
            CandidateBacked: AugmentedEvent<ApiType, [PolkadotPrimitivesVstagingCandidateReceiptV2, Bytes, u32, u32]>;
            /**
             * A candidate was included. `[candidate, head_data]`
             **/
            CandidateIncluded: AugmentedEvent<ApiType, [PolkadotPrimitivesVstagingCandidateReceiptV2, Bytes, u32, u32]>;
            /**
             * A candidate timed out. `[candidate, head_data]`
             **/
            CandidateTimedOut: AugmentedEvent<ApiType, [PolkadotPrimitivesVstagingCandidateReceiptV2, Bytes, u32]>;
            /**
             * Some upward messages have been received and will be processed.
             **/
            UpwardMessagesReceived: AugmentedEvent<ApiType, [from: u32, count: u32], {
                from: u32;
                count: u32;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        paras: {
            /**
             * A para has been queued to execute pending actions. `para_id`
             **/
            ActionQueued: AugmentedEvent<ApiType, [u32, u32]>;
            /**
             * A new code hash has been authorized for a Para.
             **/
            CodeAuthorized: AugmentedEvent<ApiType, [paraId: u32, codeHash: H256, expireAt: u32], {
                paraId: u32;
                codeHash: H256;
                expireAt: u32;
            }>;
            /**
             * A code upgrade has been scheduled for a Para. `para_id`
             **/
            CodeUpgradeScheduled: AugmentedEvent<ApiType, [u32]>;
            /**
             * Current code has been updated for a Para. `para_id`
             **/
            CurrentCodeUpdated: AugmentedEvent<ApiType, [u32]>;
            /**
             * Current head has been updated for a Para. `para_id`
             **/
            CurrentHeadUpdated: AugmentedEvent<ApiType, [u32]>;
            /**
             * A new head has been noted for a Para. `para_id`
             **/
            NewHeadNoted: AugmentedEvent<ApiType, [u32]>;
            /**
             * The given validation code was accepted by the PVF pre-checking vote.
             * `code_hash` `para_id`
             **/
            PvfCheckAccepted: AugmentedEvent<ApiType, [H256, u32]>;
            /**
             * The given validation code was rejected by the PVF pre-checking vote.
             * `code_hash` `para_id`
             **/
            PvfCheckRejected: AugmentedEvent<ApiType, [H256, u32]>;
            /**
             * The given para either initiated or subscribed to a PVF check for the given validation
             * code. `code_hash` `para_id`
             **/
            PvfCheckStarted: AugmentedEvent<ApiType, [H256, u32]>;
            /**
             * The upgrade cooldown was removed.
             **/
            UpgradeCooldownRemoved: AugmentedEvent<ApiType, [paraId: u32], {
                paraId: u32;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        parasDisputes: {
            /**
             * A dispute has concluded for or against a candidate.
             * `\[para id, candidate hash, dispute result\]`
             **/
            DisputeConcluded: AugmentedEvent<ApiType, [H256, PolkadotRuntimeParachainsDisputesDisputeResult]>;
            /**
             * A dispute has been initiated. \[candidate hash, dispute location\]
             **/
            DisputeInitiated: AugmentedEvent<ApiType, [H256, PolkadotRuntimeParachainsDisputesDisputeLocation]>;
            /**
             * A dispute has concluded with supermajority against a candidate.
             * Block authors should no longer build on top of this head and should
             * instead revert the block at the given height. This should be the
             * number of the child of the last known valid block in the chain.
             **/
            Revert: AugmentedEvent<ApiType, [u32]>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        preimage: {
            /**
             * A preimage has ben cleared.
             **/
            Cleared: AugmentedEvent<ApiType, [hash_: H256], {
                hash_: H256;
            }>;
            /**
             * A preimage has been noted.
             **/
            Noted: AugmentedEvent<ApiType, [hash_: H256], {
                hash_: H256;
            }>;
            /**
             * A preimage has been requested.
             **/
            Requested: AugmentedEvent<ApiType, [hash_: H256], {
                hash_: H256;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        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 deposit stored for proxies or announcements was poked / updated.
             **/
            DepositPoked: AugmentedEvent<ApiType, [who: AccountId32, kind: PalletProxyDepositKind, oldDeposit: u128, newDeposit: u128], {
                who: AccountId32;
                kind: PalletProxyDepositKind;
                oldDeposit: u128;
                newDeposit: u128;
            }>;
            /**
             * A proxy was added.
             **/
            ProxyAdded: AugmentedEvent<ApiType, [delegator: AccountId32, delegatee: AccountId32, proxyType: PolkadotRuntimeConstantsProxyProxyType, delay: u32], {
                delegator: AccountId32;
                delegatee: AccountId32;
                proxyType: PolkadotRuntimeConstantsProxyProxyType;
                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: PolkadotRuntimeConstantsProxyProxyType, delay: u32], {
                delegator: AccountId32;
                delegatee: AccountId32;
                proxyType: PolkadotRuntimeConstantsProxyProxyType;
                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: PolkadotRuntimeConstantsProxyProxyType, disambiguationIndex: u16], {
                pure: AccountId32;
                who: AccountId32;
                proxyType: PolkadotRuntimeConstantsProxyProxyType;
                disambiguationIndex: u16;
            }>;
            /**
             * A pure proxy was killed by its spawner.
             **/
            PureKilled: AugmentedEvent<ApiType, [pure: AccountId32, spawner: AccountId32, proxyType: PolkadotRuntimeConstantsProxyProxyType, disambiguationIndex: u16], {
                pure: AccountId32;
                spawner: AccountId32;
                proxyType: PolkadotRuntimeConstantsProxyProxyType;
                disambiguationIndex: u16;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        rcMigrator: {
            /**
             * The accounts to be preserved on Relay Chain were set.
             **/
            AccountsPreserved: AugmentedEvent<ApiType, [accounts: Vec<AccountId32>], {
                accounts: Vec<AccountId32>;
            }>;
            /**
             * The AH UMP queue priority config was set.
             **/
            AhUmpQueuePriorityConfigSet: AugmentedEvent<ApiType, [old: PalletRcMigratorQueuePriority, new_: PalletRcMigratorQueuePriority], {
                old: PalletRcMigratorQueuePriority;
                new_: PalletRcMigratorQueuePriority;
            }>;
            /**
             * Whether the AH UMP queue was prioritized for the next block.
             **/
            AhUmpQueuePrioritySet: AugmentedEvent<ApiType, [prioritized: bool, cycleBlock: u32, cyclePeriod: u32], {
                prioritized: bool;
                cycleBlock: u32;
                cyclePeriod: u32;
            }>;
            /**
             * The Asset Hub Migration finished.
             *
             * This event is equivalent to `StageTransition { new: MigrationDone, .. }` but is easier
             * to understand. The finishing is immediate and affects all events happening
             * afterwards.
             **/
            AssetHubMigrationFinished: AugmentedEvent<ApiType, []>;
            /**
             * The Asset Hub Migration started and is active until `AssetHubMigrationFinished` is
             * emitted.
             *
             * This event is equivalent to `StageTransition { new: Initializing, .. }` but is easier
             * to understand. The activation is immediate and affects all events happening
             * afterwards.
             **/
            AssetHubMigrationStarted: AugmentedEvent<ApiType, []>;
            /**
             * The canceller account id was set.
             **/
            CancellerSet: AugmentedEvent<ApiType, [old: Option<AccountId32>, new_: Option<AccountId32>], {
                old: Option<AccountId32>;
                new_: Option<AccountId32>;
            }>;
            /**
             * The manager multisig dispatched something.
             **/
            ManagerMultisigDispatched: AugmentedEvent<ApiType, [res: Result<Null, SpRuntimeDispatchError>], {
                res: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * The manager multisig received a vote.
             **/
            ManagerMultisigVoted: AugmentedEvent<ApiType, [votes: u32], {
                votes: u32;
            }>;
            /**
             * The manager account id was set.
             **/
            ManagerSet: AugmentedEvent<ApiType, [old: Option<AccountId32>, new_: Option<AccountId32>], {
                old: Option<AccountId32>;
                new_: Option<AccountId32>;
            }>;
            /**
             * The RC kept balance was consumed.
             **/
            MigratedBalanceConsumed: AugmentedEvent<ApiType, [kept: u128, migrated: u128], {
                kept: u128;
                migrated: u128;
            }>;
            /**
             * The total issuance was recorded.
             **/
            MigratedBalanceRecordSet: AugmentedEvent<ApiType, [kept: u128, migrated: u128], {
                kept: u128;
                migrated: u128;
            }>;
            /**
             * The migration was cancelled.
             **/
            MigrationCancelled: AugmentedEvent<ApiType, []>;
            /**
             * The migration was paused.
             **/
            MigrationPaused: AugmentedEvent<ApiType, [pauseStage: PalletRcMigratorMigrationStage], {
                pauseStage: PalletRcMigratorMigrationStage;
            }>;
            /**
             * The migration settings were set.
             **/
            MigrationSettingsSet: AugmentedEvent<ApiType, [old: Option<PalletRcMigratorMigrationSettings>, new_: Option<PalletRcMigratorMigrationSettings>], {
                old: Option<PalletRcMigratorMigrationSettings>;
                new_: Option<PalletRcMigratorMigrationSettings>;
            }>;
            /**
             * Some pure accounts were indexed for possibly receiving free `Any` proxies.
             **/
            PureAccountsIndexed: AugmentedEvent<ApiType, [numPureAccounts: u32], {
                numPureAccounts: u32;
            }>;
            /**
             * A query response has been received.
             **/
            QueryResponseReceived: AugmentedEvent<ApiType, [queryId: u64, response: XcmV3MaybeErrorCode], {
                queryId: u64;
                response: XcmV3MaybeErrorCode;
            }>;
            /**
             * A stage transition has occurred.
             **/
            StageTransition: AugmentedEvent<ApiType, [old: PalletRcMigratorMigrationStage, new_: PalletRcMigratorMigrationStage], {
                old: PalletRcMigratorMigrationStage;
                new_: PalletRcMigratorMigrationStage;
            }>;
            /**
             * The staking elections were paused.
             **/
            StakingElectionsPaused: AugmentedEvent<ApiType, []>;
            /**
             * The unprocessed message buffer size has been set.
             **/
            UnprocessedMsgBufferSet: AugmentedEvent<ApiType, [new_: u32, old: u32], {
                new_: u32;
                old: u32;
            }>;
            /**
             * A XCM message has been resent.
             **/
            XcmResendAttempt: AugmentedEvent<ApiType, [queryId: u64, sendError: Option<XcmV3TraitsSendError>], {
                queryId: u64;
                sendError: Option<XcmV3TraitsSendError>;
            }>;
            /**
             * An XCM message was sent.
             **/
            XcmSent: AugmentedEvent<ApiType, [origin: StagingXcmV5Location, destination: StagingXcmV5Location, message: StagingXcmV5Xcm, messageId: U8aFixed], {
                origin: StagingXcmV5Location;
                destination: StagingXcmV5Location;
                message: StagingXcmV5Xcm;
                messageId: U8aFixed;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        referenda: {
            /**
             * A referendum has been approved and its proposal has been scheduled.
             **/
            Approved: AugmentedEvent<ApiType, [index: u32], {
                index: u32;
            }>;
            /**
             * A referendum has been cancelled.
             **/
            Cancelled: AugmentedEvent<ApiType, [index: u32, tally: PalletConvictionVotingTally], {
                index: u32;
                tally: PalletConvictionVotingTally;
            }>;
            ConfirmAborted: AugmentedEvent<ApiType, [index: u32], {
                index: u32;
            }>;
            /**
             * A referendum has ended its confirmation phase and is ready for approval.
             **/
            Confirmed: AugmentedEvent<ApiType, [index: u32, tally: PalletConvictionVotingTally], {
                index: u32;
                tally: PalletConvictionVotingTally;
            }>;
            ConfirmStarted: AugmentedEvent<ApiType, [index: u32], {
                index: u32;
            }>;
            /**
             * The decision deposit has been placed.
             **/
            DecisionDepositPlaced: AugmentedEvent<ApiType, [index: u32, who: AccountId32, amount: u128], {
                index: u32;
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * The decision deposit has been refunded.
             **/
            DecisionDepositRefunded: AugmentedEvent<ApiType, [index: u32, who: AccountId32, amount: u128], {
                index: u32;
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * A referendum has moved into the deciding phase.
             **/
            DecisionStarted: AugmentedEvent<ApiType, [index: u32, track: u16, proposal: FrameSupportPreimagesBounded, tally: PalletConvictionVotingTally], {
                index: u32;
                track: u16;
                proposal: FrameSupportPreimagesBounded;
                tally: PalletConvictionVotingTally;
            }>;
            /**
             * A deposit has been slashed.
             **/
            DepositSlashed: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * A referendum has been killed.
             **/
            Killed: AugmentedEvent<ApiType, [index: u32, tally: PalletConvictionVotingTally], {
                index: u32;
                tally: PalletConvictionVotingTally;
            }>;
            /**
             * Metadata for a referendum has been cleared.
             **/
            MetadataCleared: AugmentedEvent<ApiType, [index: u32, hash_: H256], {
                index: u32;
                hash_: H256;
            }>;
            /**
             * Metadata for a referendum has been set.
             **/
            MetadataSet: AugmentedEvent<ApiType, [index: u32, hash_: H256], {
                index: u32;
                hash_: H256;
            }>;
            /**
             * A proposal has been rejected by referendum.
             **/
            Rejected: AugmentedEvent<ApiType, [index: u32, tally: PalletConvictionVotingTally], {
                index: u32;
                tally: PalletConvictionVotingTally;
            }>;
            /**
             * The submission deposit has been refunded.
             **/
            SubmissionDepositRefunded: AugmentedEvent<ApiType, [index: u32, who: AccountId32, amount: u128], {
                index: u32;
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * A referendum has been submitted.
             **/
            Submitted: AugmentedEvent<ApiType, [index: u32, track: u16, proposal: FrameSupportPreimagesBounded], {
                index: u32;
                track: u16;
                proposal: FrameSupportPreimagesBounded;
            }>;
            /**
             * A referendum has been timed out without being decided.
             **/
            TimedOut: AugmentedEvent<ApiType, [index: u32, tally: PalletConvictionVotingTally], {
                index: u32;
                tally: PalletConvictionVotingTally;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        registrar: {
            Deregistered: AugmentedEvent<ApiType, [paraId: u32], {
                paraId: u32;
            }>;
            Registered: AugmentedEvent<ApiType, [paraId: u32, manager: AccountId32], {
                paraId: u32;
                manager: AccountId32;
            }>;
            Reserved: AugmentedEvent<ApiType, [paraId: u32, who: AccountId32], {
                paraId: u32;
                who: AccountId32;
            }>;
            Swapped: AugmentedEvent<ApiType, [paraId: u32, otherId: u32], {
                paraId: u32;
                otherId: u32;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        scheduler: {
            /**
             * Agenda is incomplete from `when`.
             **/
            AgendaIncomplete: AugmentedEvent<ApiType, [when: u32], {
                when: u32;
            }>;
            /**
             * The call for the provided hash was not found so the task has been aborted.
             **/
            CallUnavailable: AugmentedEvent<ApiType, [task: ITuple<[u32, u32]>, id: Option<U8aFixed>], {
                task: ITuple<[u32, u32]>;
                id: Option<U8aFixed>;
            }>;
            /**
             * Canceled some task.
             **/
            Canceled: AugmentedEvent<ApiType, [when: u32, index: u32], {
                when: u32;
                index: u32;
            }>;
            /**
             * Dispatched some task.
             **/
            Dispatched: AugmentedEvent<ApiType, [task: ITuple<[u32, u32]>, id: Option<U8aFixed>, result: Result<Null, SpRuntimeDispatchError>], {
                task: ITuple<[u32, u32]>;
                id: Option<U8aFixed>;
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * The given task was unable to be renewed since the agenda is full at that block.
             **/
            PeriodicFailed: AugmentedEvent<ApiType, [task: ITuple<[u32, u32]>, id: Option<U8aFixed>], {
                task: ITuple<[u32, u32]>;
                id: Option<U8aFixed>;
            }>;
            /**
             * The given task can never be executed since it is overweight.
             **/
            PermanentlyOverweight: AugmentedEvent<ApiType, [task: ITuple<[u32, u32]>, id: Option<U8aFixed>], {
                task: ITuple<[u32, u32]>;
                id: Option<U8aFixed>;
            }>;
            /**
             * Cancel a retry configuration for some task.
             **/
            RetryCancelled: AugmentedEvent<ApiType, [task: ITuple<[u32, u32]>, id: Option<U8aFixed>], {
                task: ITuple<[u32, u32]>;
                id: Option<U8aFixed>;
            }>;
            /**
             * The given task was unable to be retried since the agenda is full at that block or there
             * was not enough weight to reschedule it.
             **/
            RetryFailed: AugmentedEvent<ApiType, [task: ITuple<[u32, u32]>, id: Option<U8aFixed>], {
                task: ITuple<[u32, u32]>;
                id: Option<U8aFixed>;
            }>;
            /**
             * Set a retry configuration for some task.
             **/
            RetrySet: AugmentedEvent<ApiType, [task: ITuple<[u32, u32]>, id: Option<U8aFixed>, period: u32, retries: u8], {
                task: ITuple<[u32, u32]>;
                id: Option<U8aFixed>;
                period: u32;
                retries: u8;
            }>;
            /**
             * Scheduled some task.
             **/
            Scheduled: AugmentedEvent<ApiType, [when: u32, index: u32], {
                when: u32;
                index: u32;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        session: {
            /**
             * The `NewSession` event in the current block also implies a new validator set to be
             * queued.
             **/
            NewQueued: AugmentedEvent<ApiType, []>;
            /**
             * 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;
            }>;
            /**
             * Validator has been disabled.
             **/
            ValidatorDisabled: AugmentedEvent<ApiType, [validator: AccountId32], {
                validator: AccountId32;
            }>;
            /**
             * Validator has been re-enabled.
             **/
            ValidatorReenabled: AugmentedEvent<ApiType, [validator: AccountId32], {
                validator: AccountId32;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        slots: {
            /**
             * A para has won the right to a continuous set of lease periods as a parachain.
             * First balance is any extra amount reserved on top of the para's existing deposit.
             * Second balance is the total amount reserved.
             **/
            Leased: AugmentedEvent<ApiType, [paraId: u32, leaser: AccountId32, periodBegin: u32, periodCount: u32, extraReserved: u128, totalAmount: u128], {
                paraId: u32;
                leaser: AccountId32;
                periodBegin: u32;
                periodCount: u32;
                extraReserved: u128;
                totalAmount: u128;
            }>;
            /**
             * A new `[lease_period]` is beginning.
             **/
            NewLeasePeriod: AugmentedEvent<ApiType, [leasePeriod: u32], {
                leasePeriod: u32;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        staking: {
            /**
             * An account has bonded this amount. \[stash, amount\]
             *
             * NOTE: This event is only emitted when funds are bonded via a dispatchable. Notably,
             * it will not be emitted for staking rewards when they are added to stake.
             **/
            Bonded: AugmentedEvent<ApiType, [stash: AccountId32, amount: u128], {
                stash: AccountId32;
                amount: u128;
            }>;
            /**
             * An account has stopped participating as either a validator or nominator.
             **/
            Chilled: AugmentedEvent<ApiType, [stash: AccountId32], {
                stash: AccountId32;
            }>;
            /**
             * Report of a controller batch deprecation.
             **/
            ControllerBatchDeprecated: AugmentedEvent<ApiType, [failures: u32], {
                failures: u32;
            }>;
            /**
             * Staking balance migrated from locks to holds, with any balance that could not be held
             * is force withdrawn.
             **/
            CurrencyMigrated: AugmentedEvent<ApiType, [stash: AccountId32, forceWithdraw: u128], {
                stash: AccountId32;
                forceWithdraw: u128;
            }>;
            /**
             * The era payout has been set; the first balance is the validator-payout; the second is
             * the remainder from the maximum amount of reward.
             **/
            EraPaid: AugmentedEvent<ApiType, [eraIndex: u32, validatorPayout: u128, remainder: u128], {
                eraIndex: u32;
                validatorPayout: u128;
                remainder: u128;
            }>;
            /**
             * A new force era mode was set.
             **/
            ForceEra: AugmentedEvent<ApiType, [mode: PalletStakingForcing], {
                mode: PalletStakingForcing;
            }>;
            /**
             * A nominator has been kicked from a validator.
             **/
            Kicked: AugmentedEvent<ApiType, [nominator: AccountId32, stash: AccountId32], {
                nominator: AccountId32;
                stash: AccountId32;
            }>;
            /**
             * An old slashing report from a prior era was discarded because it could
             * not be processed.
             **/
            OldSlashingReportDiscarded: AugmentedEvent<ApiType, [sessionIndex: u32], {
                sessionIndex: u32;
            }>;
            /**
             * A Page of stakers rewards are getting paid. `next` is `None` if all pages are claimed.
             **/
            PayoutStarted: AugmentedEvent<ApiType, [eraIndex: u32, validatorStash: AccountId32, page: u32, next: Option<u32>], {
                eraIndex: u32;
                validatorStash: AccountId32;
                page: u32;
                next: Option<u32>;
            }>;
            /**
             * The nominator has been rewarded by this amount to this destination.
             **/
            Rewarded: AugmentedEvent<ApiType, [stash: AccountId32, dest: PalletStakingRewardDestination, amount: u128], {
                stash: AccountId32;
                dest: PalletStakingRewardDestination;
                amount: u128;
            }>;
            /**
             * A staker (validator or nominator) has been slashed by the given amount.
             **/
            Slashed: AugmentedEvent<ApiType, [staker: AccountId32, amount: u128], {
                staker: AccountId32;
                amount: u128;
            }>;
            /**
             * A slash for the given validator, for the given percentage of their stake, at the given
             * era as been reported.
             **/
            SlashReported: AugmentedEvent<ApiType, [validator: AccountId32, fraction: Perbill, slashEra: u32], {
                validator: AccountId32;
                fraction: Perbill;
                slashEra: u32;
            }>;
            /**
             * Targets size limit reached.
             **/
            SnapshotTargetsSizeExceeded: AugmentedEvent<ApiType, [size_: u32], {
                size_: u32;
            }>;
            /**
             * Voters size limit reached.
             **/
            SnapshotVotersSizeExceeded: AugmentedEvent<ApiType, [size_: u32], {
                size_: u32;
            }>;
            /**
             * A new set of stakers was elected.
             **/
            StakersElected: AugmentedEvent<ApiType, []>;
            /**
             * The election failed. No new era is planned.
             **/
            StakingElectionFailed: AugmentedEvent<ApiType, []>;
            /**
             * An account has unbonded this amount.
             **/
            Unbonded: AugmentedEvent<ApiType, [stash: AccountId32, amount: u128], {
                stash: AccountId32;
                amount: u128;
            }>;
            /**
             * A validator has set their preferences.
             **/
            ValidatorPrefsSet: AugmentedEvent<ApiType, [stash: AccountId32, prefs: PalletStakingValidatorPrefs], {
                stash: AccountId32;
                prefs: PalletStakingValidatorPrefs;
            }>;
            /**
             * An account has called `withdraw_unbonded` and removed unbonding chunks worth `Balance`
             * from the unlocking queue.
             **/
            Withdrawn: AugmentedEvent<ApiType, [stash: AccountId32, amount: u128], {
                stash: AccountId32;
                amount: u128;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        stakingAhClient: {
            /**
             * We could not merge, and therefore dropped a buffered message.
             *
             * Note that this event is more resembling an error, but we use an event because in this
             * pallet we need to mutate storage upon some failures.
             **/
            CouldNotMergeAndDropped: AugmentedEvent<ApiType, []>;
            /**
             * The validator set received is way too small, as per
             * [`Config::MinimumValidatorSetSize`].
             **/
            SetTooSmallAndDropped: AugmentedEvent<ApiType, []>;
            /**
             * Something occurred that should never happen under normal operation. Logged as an event
             * for fail-safe observability.
             **/
            Unexpected: AugmentedEvent<ApiType, [PalletStakingAsyncAhClientUnexpectedKind]>;
            /**
             * A new validator set has been received.
             **/
            ValidatorSetReceived: AugmentedEvent<ApiType, [id: u32, newValidatorSetCount: u32, pruneUpTo: Option<u32>, leftover: bool], {
                id: u32;
                newValidatorSetCount: u32;
                pruneUpTo: Option<u32>;
                leftover: bool;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        stateTrieMigration: {
            /**
             * The auto migration task finished.
             **/
            AutoMigrationFinished: AugmentedEvent<ApiType, []>;
            /**
             * Migration got halted due to an error or miss-configuration.
             **/
            Halted: AugmentedEvent<ApiType, [error: PalletStateTrieMigrationError], {
                error: PalletStateTrieMigrationError;
            }>;
            /**
             * Given number of `(top, child)` keys were migrated respectively, with the given
             * `compute`.
             **/
            Migrated: AugmentedEvent<ApiType, [top: u32, child: u32, compute: PalletStateTrieMigrationMigrationCompute], {
                top: u32;
                child: u32;
                compute: PalletStateTrieMigrationMigrationCompute;
            }>;
            /**
             * Some account got slashed by the given amount.
             **/
            Slashed: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        system: {
            /**
             * `:code` was updated.
             **/
            CodeUpdated: AugmentedEvent<ApiType, []>;
            /**
             * An extrinsic failed.
             **/
            ExtrinsicFailed: AugmentedEvent<ApiType, [dispatchError: SpRuntimeDispatchError, dispatchInfo: FrameSystemDispatchEventInfo], {
                dispatchError: SpRuntimeDispatchError;
                dispatchInfo: FrameSystemDispatchEventInfo;
            }>;
            /**
             * An extrinsic completed successfully.
             **/
            ExtrinsicSuccess: AugmentedEvent<ApiType, [dispatchInfo: FrameSystemDispatchEventInfo], {
                dispatchInfo: FrameSystemDispatchEventInfo;
            }>;
            /**
             * An account was reaped.
             **/
            KilledAccount: AugmentedEvent<ApiType, [account: AccountId32], {
                account: AccountId32;
            }>;
            /**
             * A new account was created.
             **/
            NewAccount: AugmentedEvent<ApiType, [account: AccountId32], {
                account: AccountId32;
            }>;
            /**
             * An invalid authorized upgrade was rejected while trying to apply it.
             **/
            RejectedInvalidAuthorizedUpgrade: AugmentedEvent<ApiType, [codeHash: H256, error: SpRuntimeDispatchError], {
                codeHash: H256;
                error: SpRuntimeDispatchError;
            }>;
            /**
             * On on-chain remark happened.
             **/
            Remarked: AugmentedEvent<ApiType, [sender: AccountId32, hash_: H256], {
                sender: AccountId32;
                hash_: H256;
            }>;
            /**
             * An upgrade was authorized.
             **/
            UpgradeAuthorized: AugmentedEvent<ApiType, [codeHash: H256, checkVersion: bool], {
                codeHash: H256;
                checkVersion: bool;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        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;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        treasury: {
            /**
             * A new asset spend proposal has been approved.
             **/
            AssetSpendApproved: AugmentedEvent<ApiType, [index: u32, assetKind: PolkadotRuntimeCommonImplsVersionedLocatableAsset, amount: u128, beneficiary: XcmVersionedLocation, validFrom: u32, expireAt: u32], {
                index: u32;
                assetKind: PolkadotRuntimeCommonImplsVersionedLocatableAsset;
                amount: u128;
                beneficiary: XcmVersionedLocation;
                validFrom: u32;
                expireAt: u32;
            }>;
            /**
             * An approved spend was voided.
             **/
            AssetSpendVoided: AugmentedEvent<ApiType, [index: u32], {
                index: u32;
            }>;
            /**
             * Some funds have been allocated.
             **/
            Awarded: AugmentedEvent<ApiType, [proposalIndex: u32, award: u128, account: AccountId32], {
                proposalIndex: u32;
                award: u128;
                account: AccountId32;
            }>;
            /**
             * Some of our funds have been burnt.
             **/
            Burnt: AugmentedEvent<ApiType, [burntFunds: u128], {
                burntFunds: u128;
            }>;
            /**
             * Some funds have been deposited.
             **/
            Deposit: AugmentedEvent<ApiType, [value: u128], {
                value: u128;
            }>;
            /**
             * A payment happened.
             **/
            Paid: AugmentedEvent<ApiType, [index: u32, paymentId: u64], {
                index: u32;
                paymentId: u64;
            }>;
            /**
             * A payment failed and can be retried.
             **/
            PaymentFailed: AugmentedEvent<ApiType, [index: u32, paymentId: u64], {
                index: u32;
                paymentId: u64;
            }>;
            /**
             * Spending has finished; this is the amount that rolls over until next spend.
             **/
            Rollover: AugmentedEvent<ApiType, [rolloverBalance: u128], {
                rolloverBalance: u128;
            }>;
            /**
             * A new spend proposal has been approved.
             **/
            SpendApproved: AugmentedEvent<ApiType, [proposalIndex: u32, amount: u128, beneficiary: AccountId32], {
                proposalIndex: u32;
                amount: u128;
                beneficiary: AccountId32;
            }>;
            /**
             * We have ended a spend period and will now allocate funds.
             **/
            Spending: AugmentedEvent<ApiType, [budgetRemaining: u128], {
                budgetRemaining: u128;
            }>;
            /**
             * A spend was processed and removed from the storage. It might have been successfully
             * paid or it may have expired.
             **/
            SpendProcessed: AugmentedEvent<ApiType, [index: u32], {
                index: u32;
            }>;
            /**
             * The inactive funds of the pallet have been updated.
             **/
            UpdatedInactive: AugmentedEvent<ApiType, [reactivated: u128, deactivated: u128], {
                reactivated: u128;
                deactivated: u128;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        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>;
            }>;
            /**
             * The fallback call was dispatched.
             **/
            IfElseFallbackCalled: AugmentedEvent<ApiType, [mainError: SpRuntimeDispatchError], {
                mainError: SpRuntimeDispatchError;
            }>;
            /**
             * Main call was dispatched.
             **/
            IfElseMainSuccess: AugmentedEvent<ApiType, []>;
            /**
             * 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;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        vesting: {
            /**
             * An \[account\] has become fully vested.
             **/
            VestingCompleted: AugmentedEvent<ApiType, [account: AccountId32], {
                account: AccountId32;
            }>;
            /**
             * A vesting schedule has been created.
             **/
            VestingCreated: AugmentedEvent<ApiType, [account: AccountId32, scheduleIndex: u32], {
                account: AccountId32;
                scheduleIndex: u32;
            }>;
            /**
             * 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;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        voterList: {
            /**
             * Moved an account from one bag to another.
             **/
            Rebagged: AugmentedEvent<ApiType, [who: AccountId32, from: u64, to: u64], {
                who: AccountId32;
                from: u64;
                to: u64;
            }>;
            /**
             * Updated the score of some account to the given amount.
             **/
            ScoreUpdated: AugmentedEvent<ApiType, [who: AccountId32, newScore: u64], {
                who: AccountId32;
                newScore: u64;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        whitelist: {
            CallWhitelisted: AugmentedEvent<ApiType, [callHash: H256], {
                callHash: H256;
            }>;
            WhitelistedCallDispatched: AugmentedEvent<ApiType, [callHash: H256, result: Result<FrameSupportDispatchPostDispatchInfo, SpRuntimeDispatchErrorWithPostInfo>], {
                callHash: H256;
                result: Result<FrameSupportDispatchPostDispatchInfo, SpRuntimeDispatchErrorWithPostInfo>;
            }>;
            WhitelistedCallRemoved: AugmentedEvent<ApiType, [callHash: H256], {
                callHash: H256;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        xcmPallet: {
            /**
             * `target` removed alias authorization for `aliaser`.
             **/
            AliasAuthorizationRemoved: AugmentedEvent<ApiType, [aliaser: StagingXcmV5Location, target: StagingXcmV5Location], {
                aliaser: StagingXcmV5Location;
                target: StagingXcmV5Location;
            }>;
            /**
             * An `aliaser` location was authorized by `target` to alias it, authorization valid until
             * `expiry` block number.
             **/
            AliasAuthorized: AugmentedEvent<ApiType, [aliaser: StagingXcmV5Location, target: StagingXcmV5Location, expiry: Option<u64>], {
                aliaser: StagingXcmV5Location;
                target: StagingXcmV5Location;
                expiry: Option<u64>;
            }>;
            /**
             * `target` removed all alias authorizations.
             **/
            AliasesAuthorizationsRemoved: AugmentedEvent<ApiType, [target: StagingXcmV5Location], {
                target: StagingXcmV5Location;
            }>;
            /**
             * Some assets have been claimed from an asset trap
             **/
            AssetsClaimed: AugmentedEvent<ApiType, [hash_: H256, origin: StagingXcmV5Location, assets: XcmVersionedAssets], {
                hash_: H256;
                origin: StagingXcmV5Location;
                assets: XcmVersionedAssets;
            }>;
            /**
             * Some assets have been placed in an asset trap.
             **/
            AssetsTrapped: AugmentedEvent<ApiType, [hash_: H256, origin: StagingXcmV5Location, assets: XcmVersionedAssets], {
                hash_: H256;
                origin: StagingXcmV5Location;
                assets: XcmVersionedAssets;
            }>;
            /**
             * Execution of an XCM message was attempted.
             **/
            Attempted: AugmentedEvent<ApiType, [outcome: StagingXcmV5TraitsOutcome], {
                outcome: StagingXcmV5TraitsOutcome;
            }>;
            /**
             * Fees were paid from a location for an operation (often for using `SendXcm`).
             **/
            FeesPaid: AugmentedEvent<ApiType, [paying: StagingXcmV5Location, fees: StagingXcmV5AssetAssets], {
                paying: StagingXcmV5Location;
                fees: StagingXcmV5AssetAssets;
            }>;
            /**
             * Expected query response has been received but the querier location of the response does
             * not match the expected. The query remains registered for a later, valid, response to
             * be received and acted upon.
             **/
            InvalidQuerier: AugmentedEvent<ApiType, [origin: StagingXcmV5Location, queryId: u64, expectedQuerier: StagingXcmV5Location, maybeActualQuerier: Option<StagingXcmV5Location>], {
                origin: StagingXcmV5Location;
                queryId: u64;
                expectedQuerier: StagingXcmV5Location;
                maybeActualQuerier: Option<StagingXcmV5Location>;
            }>;
            /**
             * Expected query response has been received but the expected querier 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.
             **/
            InvalidQuerierVersion: AugmentedEvent<ApiType, [origin: StagingXcmV5Location, queryId: u64], {
                origin: StagingXcmV5Location;
                queryId: u64;
            }>;
            /**
             * 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.
             **/
            InvalidResponder: AugmentedEvent<ApiType, [origin: StagingXcmV5Location, queryId: u64, expectedLocation: Option<StagingXcmV5Location>], {
                origin: StagingXcmV5Location;
                queryId: u64;
                expectedLocation: Option<StagingXcmV5Location>;
            }>;
            /**
             * 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.
             **/
            InvalidResponderVersion: AugmentedEvent<ApiType, [origin: StagingXcmV5Location, queryId: u64], {
                origin: StagingXcmV5Location;
                queryId: u64;
            }>;
            /**
             * Query response has been received and query is removed. The registered notification has
             * been dispatched and executed successfully.
             **/
            Notified: AugmentedEvent<ApiType, [queryId: u64, palletIndex: u8, callIndex: u8], {
                queryId: u64;
                palletIndex: u8;
                callIndex: 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)`.
             **/
            NotifyDecodeFailed: AugmentedEvent<ApiType, [queryId: u64, palletIndex: u8, callIndex: u8], {
                queryId: u64;
                palletIndex: u8;
                callIndex: u8;
            }>;
            /**
             * Query response has been received and query is removed. There was a general error with
             * dispatching the notification call.
             **/
            NotifyDispatchError: AugmentedEvent<ApiType, [queryId: u64, palletIndex: u8, callIndex: u8], {
                queryId: u64;
                palletIndex: u8;
                callIndex: 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.
             **/
            NotifyOverweight: AugmentedEvent<ApiType, [queryId: u64, palletIndex: u8, callIndex: u8, actualWeight: SpWeightsWeightV2Weight, maxBudgetedWeight: SpWeightsWeightV2Weight], {
                queryId: u64;
                palletIndex: u8;
                callIndex: u8;
                actualWeight: SpWeightsWeightV2Weight;
                maxBudgetedWeight: SpWeightsWeightV2Weight;
            }>;
            /**
             * A given location which had a version change subscription was dropped owing to an error
             * migrating the location to our new XCM format.
             **/
            NotifyTargetMigrationFail: AugmentedEvent<ApiType, [location: XcmVersionedLocation, queryId: u64], {
                location: XcmVersionedLocation;
                queryId: u64;
            }>;
            /**
             * A given location which had a version change subscription was dropped owing to an error
             * sending the notification to it.
             **/
            NotifyTargetSendFail: AugmentedEvent<ApiType, [location: StagingXcmV5Location, queryId: u64, error: XcmV5TraitsError], {
                location: StagingXcmV5Location;
                queryId: u64;
                error: XcmV5TraitsError;
            }>;
            /**
             * An XCM message failed to process.
             **/
            ProcessXcmError: AugmentedEvent<ApiType, [origin: StagingXcmV5Location, error: XcmV5TraitsError, messageId: U8aFixed], {
                origin: StagingXcmV5Location;
                error: XcmV5TraitsError;
                messageId: U8aFixed;
            }>;
            /**
             * Query response has been received and is ready for taking with `take_response`. There is
             * no registered notification call.
             **/
            ResponseReady: AugmentedEvent<ApiType, [queryId: u64, response: StagingXcmV5Response], {
                queryId: u64;
                response: StagingXcmV5Response;
            }>;
            /**
             * Received query response has been read and removed.
             **/
            ResponseTaken: AugmentedEvent<ApiType, [queryId: u64], {
                queryId: u64;
            }>;
            /**
             * An XCM message failed to send.
             **/
            SendFailed: AugmentedEvent<ApiType, [origin: StagingXcmV5Location, destination: StagingXcmV5Location, error: XcmV3TraitsSendError, messageId: U8aFixed], {
                origin: StagingXcmV5Location;
                destination: StagingXcmV5Location;
                error: XcmV3TraitsSendError;
                messageId: U8aFixed;
            }>;
            /**
             * An XCM message was sent.
             **/
            Sent: AugmentedEvent<ApiType, [origin: StagingXcmV5Location, destination: StagingXcmV5Location, message: StagingXcmV5Xcm, messageId: U8aFixed], {
                origin: StagingXcmV5Location;
                destination: StagingXcmV5Location;
                message: StagingXcmV5Xcm;
                messageId: U8aFixed;
            }>;
            /**
             * The supported version of a location has been changed. This might be through an
             * automatic notification or a manual intervention.
             **/
            SupportedVersionChanged: AugmentedEvent<ApiType, [location: StagingXcmV5Location, version: u32], {
                location: StagingXcmV5Location;
                version: 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.
             **/
            UnexpectedResponse: AugmentedEvent<ApiType, [origin: StagingXcmV5Location, queryId: u64], {
                origin: StagingXcmV5Location;
                queryId: u64;
            }>;
            /**
             * An XCM version change notification message has been attempted to be sent.
             *
             * The cost of sending it (borne by the chain) is included.
             **/
            VersionChangeNotified: AugmentedEvent<ApiType, [destination: StagingXcmV5Location, result: u32, cost: StagingXcmV5AssetAssets, messageId: U8aFixed], {
                destination: StagingXcmV5Location;
                result: u32;
                cost: StagingXcmV5AssetAssets;
                messageId: U8aFixed;
            }>;
            /**
             * A XCM version migration finished.
             **/
            VersionMigrationFinished: AugmentedEvent<ApiType, [version: u32], {
                version: u32;
            }>;
            /**
             * We have requested that a remote chain send us XCM version change notifications.
             **/
            VersionNotifyRequested: AugmentedEvent<ApiType, [destination: StagingXcmV5Location, cost: StagingXcmV5AssetAssets, messageId: U8aFixed], {
                destination: StagingXcmV5Location;
                cost: StagingXcmV5AssetAssets;
                messageId: U8aFixed;
            }>;
            /**
             * A remote has requested XCM version change notification from us and we have honored it.
             * A version information message is sent to them and its cost is included.
             **/
            VersionNotifyStarted: AugmentedEvent<ApiType, [destination: StagingXcmV5Location, cost: StagingXcmV5AssetAssets, messageId: U8aFixed], {
                destination: StagingXcmV5Location;
                cost: StagingXcmV5AssetAssets;
                messageId: U8aFixed;
            }>;
            /**
             * We have requested that a remote chain stops sending us XCM version change
             * notifications.
             **/
            VersionNotifyUnrequested: AugmentedEvent<ApiType, [destination: StagingXcmV5Location, cost: StagingXcmV5AssetAssets, messageId: U8aFixed], {
                destination: StagingXcmV5Location;
                cost: StagingXcmV5AssetAssets;
                messageId: U8aFixed;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
    }
}