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 { AccountId32, H256 } from '@polkadot/types/interfaces/runtime';
import type { CommonPrimitivesSchemaPayloadLocation, CommonRuntimeProxyProxyType, FrameSupportTokensMiscBalanceStatus, FrameSystemDispatchEventInfo, PalletDemocracyMetadataOwner, PalletDemocracyVoteAccountVote, PalletDemocracyVoteThreshold, PalletMultisigTimepoint, PalletProxyDepositKind, PalletTimeReleaseReleaseSchedule, SpRuntimeDispatchError, SpWeightsWeightV2Weight } from '@polkadot/types/lookup';
export type __AugmentedEvent<ApiType extends ApiTypes> = AugmentedEvent<ApiType>;
declare module '@polkadot/api-base/types/events' {
    interface AugmentedEvents<ApiType extends ApiTypes> {
        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;
            }>;
            /**
             * 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>;
        };
        capacity: {
            /**
             * Capacity has been withdrawn from a MessageSourceId.
             **/
            CapacityWithdrawn: AugmentedEvent<ApiType, [msaId: u64, amount: u128], {
                msaId: u64;
                amount: u128;
            }>;
            /**
             * The Capacity epoch length was changed.
             **/
            EpochLengthUpdated: AugmentedEvent<ApiType, [blocks: u32], {
                blocks: u32;
            }>;
            /**
             * Tokens have been staked on the network for Provider Boosting
             **/
            ProviderBoosted: AugmentedEvent<ApiType, [account: AccountId32, target: u64, amount: u128, capacity: u128], {
                account: AccountId32;
                target: u64;
                amount: u128;
                capacity: u128;
            }>;
            /**
             * Provider Boost Token Rewards have been minted and transferred to the staking account.
             **/
            ProviderBoostRewardClaimed: AugmentedEvent<ApiType, [account: AccountId32, rewardAmount: u128], {
                account: AccountId32;
                rewardAmount: u128;
            }>;
            /**
             * Tokens have been staked to the Frequency network.
             **/
            Staked: AugmentedEvent<ApiType, [account: AccountId32, target: u64, amount: u128, capacity: u128], {
                account: AccountId32;
                target: u64;
                amount: u128;
                capacity: u128;
            }>;
            /**
             * Unstaked token that has thawed was unlocked for the given account
             **/
            StakeWithdrawn: AugmentedEvent<ApiType, [account: AccountId32, amount: u128], {
                account: AccountId32;
                amount: u128;
            }>;
            /**
             * The target of a staked amount was changed to a new MessageSourceId
             **/
            StakingTargetChanged: AugmentedEvent<ApiType, [account: AccountId32, fromMsa: u64, toMsa: u64, amount: u128], {
                account: AccountId32;
                fromMsa: u64;
                toMsa: u64;
                amount: u128;
            }>;
            /**
             * A token account has unstaked the Frequency network.
             **/
            UnStaked: AugmentedEvent<ApiType, [account: AccountId32, target: u64, amount: u128, capacity: u128], {
                account: AccountId32;
                target: u64;
                amount: u128;
                capacity: u128;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        collatorSelection: {
            /**
             * A new candidate joined.
             **/
            CandidateAdded: AugmentedEvent<ApiType, [accountId: AccountId32, deposit: u128], {
                accountId: AccountId32;
                deposit: u128;
            }>;
            /**
             * Bond of a candidate updated.
             **/
            CandidateBondUpdated: AugmentedEvent<ApiType, [accountId: AccountId32, deposit: u128], {
                accountId: AccountId32;
                deposit: u128;
            }>;
            /**
             * A candidate was removed.
             **/
            CandidateRemoved: AugmentedEvent<ApiType, [accountId: AccountId32], {
                accountId: AccountId32;
            }>;
            /**
             * An account was replaced in the candidate list by another one.
             **/
            CandidateReplaced: AugmentedEvent<ApiType, [old: AccountId32, new_: AccountId32, deposit: u128], {
                old: AccountId32;
                new_: AccountId32;
                deposit: u128;
            }>;
            /**
             * An account was unable to be added to the Invulnerables because they did not have keys
             * registered. Other Invulnerables may have been set.
             **/
            InvalidInvulnerableSkipped: AugmentedEvent<ApiType, [accountId: AccountId32], {
                accountId: AccountId32;
            }>;
            /**
             * A new Invulnerable was added.
             **/
            InvulnerableAdded: AugmentedEvent<ApiType, [accountId: AccountId32], {
                accountId: AccountId32;
            }>;
            /**
             * An Invulnerable was removed.
             **/
            InvulnerableRemoved: AugmentedEvent<ApiType, [accountId: AccountId32], {
                accountId: AccountId32;
            }>;
            /**
             * The candidacy bond was set.
             **/
            NewCandidacyBond: AugmentedEvent<ApiType, [bondAmount: u128], {
                bondAmount: u128;
            }>;
            /**
             * The number of desired candidates was set.
             **/
            NewDesiredCandidates: AugmentedEvent<ApiType, [desiredCandidates: u32], {
                desiredCandidates: u32;
            }>;
            /**
             * New Invulnerables were set.
             **/
            NewInvulnerables: AugmentedEvent<ApiType, [invulnerables: Vec<AccountId32>], {
                invulnerables: Vec<AccountId32>;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        council: {
            /**
             * A motion was approved by the required threshold.
             **/
            Approved: AugmentedEvent<ApiType, [proposalHash: H256], {
                proposalHash: H256;
            }>;
            /**
             * A proposal was closed because its threshold was reached or after its duration was up.
             **/
            Closed: AugmentedEvent<ApiType, [proposalHash: H256, yes: u32, no: u32], {
                proposalHash: H256;
                yes: u32;
                no: u32;
            }>;
            /**
             * A motion was not approved by the required threshold.
             **/
            Disapproved: AugmentedEvent<ApiType, [proposalHash: H256], {
                proposalHash: H256;
            }>;
            /**
             * A motion was executed; result will be `Ok` if it returned without error.
             **/
            Executed: AugmentedEvent<ApiType, [proposalHash: H256, result: Result<Null, SpRuntimeDispatchError>], {
                proposalHash: H256;
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * A proposal was killed.
             **/
            Killed: AugmentedEvent<ApiType, [proposalHash: H256], {
                proposalHash: H256;
            }>;
            /**
             * A single member did some action; result will be `Ok` if it returned without error.
             **/
            MemberExecuted: AugmentedEvent<ApiType, [proposalHash: H256, result: Result<Null, SpRuntimeDispatchError>], {
                proposalHash: H256;
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * Some cost for storing a proposal was burned.
             **/
            ProposalCostBurned: AugmentedEvent<ApiType, [proposalHash: H256, who: AccountId32], {
                proposalHash: H256;
                who: AccountId32;
            }>;
            /**
             * Some cost for storing a proposal was released.
             **/
            ProposalCostReleased: AugmentedEvent<ApiType, [proposalHash: H256, who: AccountId32], {
                proposalHash: H256;
                who: AccountId32;
            }>;
            /**
             * A motion (given hash) has been proposed (by given account) with a threshold (given
             * `MemberCount`).
             **/
            Proposed: AugmentedEvent<ApiType, [account: AccountId32, proposalIndex: u32, proposalHash: H256, threshold: u32], {
                account: AccountId32;
                proposalIndex: u32;
                proposalHash: H256;
                threshold: u32;
            }>;
            /**
             * A motion (given hash) has been voted on by given account, leaving
             * a tally (yes votes and no votes given respectively as `MemberCount`).
             **/
            Voted: AugmentedEvent<ApiType, [account: AccountId32, proposalHash: H256, voted: bool, yes: u32, no: u32], {
                account: AccountId32;
                proposalHash: H256;
                voted: bool;
                yes: u32;
                no: u32;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        democracy: {
            /**
             * A proposal_hash has been blacklisted permanently.
             **/
            Blacklisted: AugmentedEvent<ApiType, [proposalHash: H256], {
                proposalHash: H256;
            }>;
            /**
             * A referendum has been cancelled.
             **/
            Cancelled: AugmentedEvent<ApiType, [refIndex: u32], {
                refIndex: u32;
            }>;
            /**
             * An account has delegated their vote to another account.
             **/
            Delegated: AugmentedEvent<ApiType, [who: AccountId32, target: AccountId32], {
                who: AccountId32;
                target: AccountId32;
            }>;
            /**
             * An external proposal has been tabled.
             **/
            ExternalTabled: AugmentedEvent<ApiType, []>;
            /**
             * Metadata for a proposal or a referendum has been cleared.
             **/
            MetadataCleared: AugmentedEvent<ApiType, [owner: PalletDemocracyMetadataOwner, hash_: H256], {
                owner: PalletDemocracyMetadataOwner;
                hash_: H256;
            }>;
            /**
             * Metadata for a proposal or a referendum has been set.
             **/
            MetadataSet: AugmentedEvent<ApiType, [owner: PalletDemocracyMetadataOwner, hash_: H256], {
                owner: PalletDemocracyMetadataOwner;
                hash_: H256;
            }>;
            /**
             * Metadata has been transferred to new owner.
             **/
            MetadataTransferred: AugmentedEvent<ApiType, [prevOwner: PalletDemocracyMetadataOwner, owner: PalletDemocracyMetadataOwner, hash_: H256], {
                prevOwner: PalletDemocracyMetadataOwner;
                owner: PalletDemocracyMetadataOwner;
                hash_: H256;
            }>;
            /**
             * A proposal has been rejected by referendum.
             **/
            NotPassed: AugmentedEvent<ApiType, [refIndex: u32], {
                refIndex: u32;
            }>;
            /**
             * A proposal has been approved by referendum.
             **/
            Passed: AugmentedEvent<ApiType, [refIndex: u32], {
                refIndex: u32;
            }>;
            /**
             * A proposal got canceled.
             **/
            ProposalCanceled: AugmentedEvent<ApiType, [propIndex: u32], {
                propIndex: u32;
            }>;
            /**
             * A motion has been proposed by a public account.
             **/
            Proposed: AugmentedEvent<ApiType, [proposalIndex: u32, deposit: u128], {
                proposalIndex: u32;
                deposit: u128;
            }>;
            /**
             * An account has seconded a proposal
             **/
            Seconded: AugmentedEvent<ApiType, [seconder: AccountId32, propIndex: u32], {
                seconder: AccountId32;
                propIndex: u32;
            }>;
            /**
             * A referendum has begun.
             **/
            Started: AugmentedEvent<ApiType, [refIndex: u32, threshold: PalletDemocracyVoteThreshold], {
                refIndex: u32;
                threshold: PalletDemocracyVoteThreshold;
            }>;
            /**
             * A public proposal has been tabled for referendum vote.
             **/
            Tabled: AugmentedEvent<ApiType, [proposalIndex: u32, deposit: u128], {
                proposalIndex: u32;
                deposit: u128;
            }>;
            /**
             * An account has cancelled a previous delegation operation.
             **/
            Undelegated: AugmentedEvent<ApiType, [account: AccountId32], {
                account: AccountId32;
            }>;
            /**
             * An external proposal has been vetoed.
             **/
            Vetoed: AugmentedEvent<ApiType, [who: AccountId32, proposalHash: H256, until: u32], {
                who: AccountId32;
                proposalHash: H256;
                until: u32;
            }>;
            /**
             * An account has voted in a referendum
             **/
            Voted: AugmentedEvent<ApiType, [voter: AccountId32, refIndex: u32, vote: PalletDemocracyVoteAccountVote], {
                voter: AccountId32;
                refIndex: u32;
                vote: PalletDemocracyVoteAccountVote;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        frequencyTxPayment: {
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        handles: {
            /**
             * Deposited when a handle is claimed. [MSA id, display handle in UTF-8 bytes]
             **/
            HandleClaimed: AugmentedEvent<ApiType, [msaId: u64, handle: Bytes], {
                msaId: u64;
                handle: Bytes;
            }>;
            /**
             * Deposited when a handle is retired. [MSA id, display handle in UTF-8 bytes]
             **/
            HandleRetired: AugmentedEvent<ApiType, [msaId: u64, handle: Bytes], {
                msaId: u64;
                handle: Bytes;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        messages: {
            /**
             * Messages stored in the current block
             **/
            MessagesInBlock: AugmentedEvent<ApiType, []>;
            /**
             * Event emitted during storage migration to track progress
             **/
            MessagesMigrated: AugmentedEvent<ApiType, [fromVersion: u16, toVersion: u16, cumulativeTotalMigrated: u64], {
                fromVersion: u16;
                toVersion: u16;
                cumulativeTotalMigrated: u64;
            }>;
            /**
             * Deprecated: please use [`Event::MessagesInBlock`]
             * Messages are stored for a specified schema id and block number
             **/
            MessagesStored: AugmentedEvent<ApiType, [schemaId: u16, blockNumber: u32], {
                schemaId: u16;
                blockNumber: u32;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        msa: {
            /**
             * An account was recovered with a new control key
             **/
            AccountRecovered: AugmentedEvent<ApiType, [msaId: u64, recoveryProvider: u64, newControlKey: AccountId32], {
                msaId: u64;
                recoveryProvider: u64;
                newControlKey: AccountId32;
            }>;
            /**
             * Application updated for provider
             **/
            ApplicationContextUpdated: AugmentedEvent<ApiType, [providerId: u64, applicationId: Option<u16>], {
                providerId: u64;
                applicationId: Option<u16>;
            }>;
            /**
             * Application for provider created
             **/
            ApplicationCreated: AugmentedEvent<ApiType, [providerId: u64, applicationId: u16], {
                providerId: u64;
                applicationId: u16;
            }>;
            /**
             * A delegation relationship was added with the given provider and delegator
             **/
            DelegationGranted: AugmentedEvent<ApiType, [providerId: u64, delegatorId: u64], {
                providerId: u64;
                delegatorId: u64;
            }>;
            /**
             * The Delegator revoked its delegation to the Provider
             **/
            DelegationRevoked: AugmentedEvent<ApiType, [providerId: u64, delegatorId: u64], {
                providerId: u64;
                delegatorId: u64;
            }>;
            /**
             * A an update to the delegation occurred (ex. schema permissions where updated).
             **/
            DelegationUpdated: AugmentedEvent<ApiType, [providerId: u64, delegatorId: u64], {
                providerId: u64;
                delegatorId: u64;
            }>;
            /**
             * A new Message Service Account was created with a new MessageSourceId
             **/
            MsaCreated: AugmentedEvent<ApiType, [msaId: u64, key: AccountId32], {
                msaId: u64;
                key: AccountId32;
            }>;
            /**
             * The MSA has been retired.
             **/
            MsaRetired: AugmentedEvent<ApiType, [msaId: u64], {
                msaId: u64;
            }>;
            /**
             * A Provider-MSA relationship was registered
             **/
            ProviderCreated: AugmentedEvent<ApiType, [providerId: u64], {
                providerId: u64;
            }>;
            /**
             * Provider registry is updated
             **/
            ProviderUpdated: AugmentedEvent<ApiType, [providerId: u64], {
                providerId: u64;
            }>;
            /**
             * An AccountId has been associated with a MessageSourceId
             **/
            PublicKeyAdded: AugmentedEvent<ApiType, [msaId: u64, key: AccountId32], {
                msaId: u64;
                key: AccountId32;
            }>;
            /**
             * An AccountId had all permissions revoked from its MessageSourceId
             **/
            PublicKeyDeleted: AugmentedEvent<ApiType, [key: AccountId32], {
                key: AccountId32;
            }>;
            /**
             * A Recovery Commitment was added to an MSA
             **/
            RecoveryCommitmentAdded: AugmentedEvent<ApiType, [who: AccountId32, msaId: u64, recoveryCommitment: U8aFixed], {
                who: AccountId32;
                msaId: u64;
                recoveryCommitment: U8aFixed;
            }>;
            /**
             * A Recovery Commitment was invalidated after use or removal
             **/
            RecoveryCommitmentInvalidated: AugmentedEvent<ApiType, [msaId: u64, recoveryCommitment: U8aFixed], {
                msaId: u64;
                recoveryCommitment: U8aFixed;
            }>;
            /**
             * A recovery provider has been approved.
             **/
            RecoveryProviderApproved: AugmentedEvent<ApiType, [providerId: u64], {
                providerId: u64;
            }>;
            /**
             * A recovery provider has been removed.
             **/
            RecoveryProviderRemoved: AugmentedEvent<ApiType, [providerId: u64], {
                providerId: u64;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        multiBlockMigrations: {
            /**
             * The set of historical migrations has been cleared.
             **/
            HistoricCleared: AugmentedEvent<ApiType, [nextCursor: Option<Bytes>], {
                nextCursor: Option<Bytes>;
            }>;
            /**
             * A migration progressed.
             **/
            MigrationAdvanced: AugmentedEvent<ApiType, [index: u32, took: u32], {
                index: u32;
                took: u32;
            }>;
            /**
             * A Migration completed.
             **/
            MigrationCompleted: AugmentedEvent<ApiType, [index: u32, took: u32], {
                index: u32;
                took: u32;
            }>;
            /**
             * A Migration failed.
             *
             * This implies that the whole upgrade failed and governance intervention is required.
             **/
            MigrationFailed: AugmentedEvent<ApiType, [index: u32, took: u32], {
                index: u32;
                took: u32;
            }>;
            /**
             * A migration was skipped since it was already executed in the past.
             **/
            MigrationSkipped: AugmentedEvent<ApiType, [index: u32], {
                index: u32;
            }>;
            /**
             * The current runtime upgrade completed.
             *
             * This implies that all of its migrations completed successfully as well.
             **/
            UpgradeCompleted: AugmentedEvent<ApiType, []>;
            /**
             * Runtime upgrade failed.
             *
             * This is very bad and will require governance intervention.
             **/
            UpgradeFailed: AugmentedEvent<ApiType, []>;
            /**
             * A Runtime upgrade started.
             *
             * Its end is indicated by `UpgradeCompleted` or `UpgradeFailed`.
             **/
            UpgradeStarted: AugmentedEvent<ApiType, [migrations: u32], {
                migrations: u32;
            }>;
            /**
             * 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>;
        };
        parachainSystem: {
            /**
             * Downward messages were processed using the given weight.
             **/
            DownwardMessagesProcessed: AugmentedEvent<ApiType, [weightUsed: SpWeightsWeightV2Weight, dmqHead: H256], {
                weightUsed: SpWeightsWeightV2Weight;
                dmqHead: H256;
            }>;
            /**
             * Some downward messages have been received and will be processed.
             **/
            DownwardMessagesReceived: AugmentedEvent<ApiType, [count: u32], {
                count: u32;
            }>;
            /**
             * An upward message was sent to the relay chain.
             **/
            UpwardMessageSent: AugmentedEvent<ApiType, [messageHash: Option<U8aFixed>], {
                messageHash: Option<U8aFixed>;
            }>;
            /**
             * The validation function was applied as of the contained relay chain block number.
             **/
            ValidationFunctionApplied: AugmentedEvent<ApiType, [relayChainBlockNum: u32], {
                relayChainBlockNum: u32;
            }>;
            /**
             * The relay-chain aborted the upgrade process.
             **/
            ValidationFunctionDiscarded: AugmentedEvent<ApiType, []>;
            /**
             * The validation function has been scheduled to apply.
             **/
            ValidationFunctionStored: AugmentedEvent<ApiType, []>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        passkey: {
            /**
             * When a passkey transaction is successfully executed
             **/
            TransactionExecutionSuccess: AugmentedEvent<ApiType, [accountId: AccountId32], {
                accountId: AccountId32;
            }>;
            /**
             * 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: CommonRuntimeProxyProxyType, delay: u32], {
                delegator: AccountId32;
                delegatee: AccountId32;
                proxyType: CommonRuntimeProxyProxyType;
                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: CommonRuntimeProxyProxyType, delay: u32], {
                delegator: AccountId32;
                delegatee: AccountId32;
                proxyType: CommonRuntimeProxyProxyType;
                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: CommonRuntimeProxyProxyType, disambiguationIndex: u16], {
                pure: AccountId32;
                who: AccountId32;
                proxyType: CommonRuntimeProxyProxyType;
                disambiguationIndex: u16;
            }>;
            /**
             * A pure proxy was killed by its spawner.
             **/
            PureKilled: AugmentedEvent<ApiType, [pure: AccountId32, spawner: AccountId32, proxyType: CommonRuntimeProxyProxyType, disambiguationIndex: u16], {
                pure: AccountId32;
                spawner: AccountId32;
                proxyType: CommonRuntimeProxyProxyType;
                disambiguationIndex: u16;
            }>;
            /**
             * 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>;
        };
        schemas: {
            /**
             * Emitted when an Intent is registered
             **/
            IntentCreated: AugmentedEvent<ApiType, [key: AccountId32, intentId: u16, intentName: Bytes], {
                key: AccountId32;
                intentId: u16;
                intentName: Bytes;
            }>;
            /**
             * Emitted when an IntentGroup is registered
             **/
            IntentGroupCreated: AugmentedEvent<ApiType, [key: AccountId32, intentGroupId: u16, intentGroupName: Bytes], {
                key: AccountId32;
                intentGroupId: u16;
                intentGroupName: Bytes;
            }>;
            /**
             * Emitted when an IntentGroup is updated
             **/
            IntentGroupUpdated: AugmentedEvent<ApiType, [key: AccountId32, intentGroupId: u16], {
                key: AccountId32;
                intentGroupId: u16;
            }>;
            /**
             * Emitted when a schema is registered. [who, schemas id]
             **/
            SchemaCreated: AugmentedEvent<ApiType, [key: AccountId32, schemaId: u16], {
                key: AccountId32;
                schemaId: u16;
            }>;
            /**
             * Emitted when maximum size for schema model is changed.
             **/
            SchemaMaxSizeChanged: AugmentedEvent<ApiType, [maxSize: u32], {
                maxSize: u32;
            }>;
            /**
             * Emitted when a schema is assigned a name
             **/
            SchemaNameCreated: AugmentedEvent<ApiType, [schemaId: u16, name: Bytes], {
                schemaId: u16;
                name: Bytes;
            }>;
            /**
             * 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>;
        };
        statefulStorage: {
            /**
             * An event for when an itemized storage is deleted
             **/
            ItemizedPageDeleted: AugmentedEvent<ApiType, [msaId: u64, intentId: u16, prevContentHash: u32], {
                msaId: u64;
                intentId: u16;
                prevContentHash: u32;
            }>;
            /**
             * An event for when an itemized storage is updated
             **/
            ItemizedPageUpdated: AugmentedEvent<ApiType, [msaId: u64, intentId: u16, prevContentHash: u32, currContentHash: u32], {
                msaId: u64;
                intentId: u16;
                prevContentHash: u32;
                currContentHash: u32;
            }>;
            /**
             * An event for when an paginated storage is deleted
             **/
            PaginatedPageDeleted: AugmentedEvent<ApiType, [msaId: u64, intentId: u16, pageId: u16, prevContentHash: u32], {
                msaId: u64;
                intentId: u16;
                pageId: u16;
                prevContentHash: u32;
            }>;
            /**
             * An event for when an paginated storage is updated
             **/
            PaginatedPageUpdated: AugmentedEvent<ApiType, [msaId: u64, intentId: u16, pageId: u16, prevContentHash: u32, currContentHash: u32], {
                msaId: u64;
                intentId: u16;
                pageId: u16;
                prevContentHash: u32;
                currContentHash: u32;
            }>;
            /**
             * An event to track storage migrations
             **/
            StatefulPagesMigrated: AugmentedEvent<ApiType, [lastTrie: ITuple<[u64, CommonPrimitivesSchemaPayloadLocation]>, totalPageCount: u64], {
                lastTrie: ITuple<[u64, CommonPrimitivesSchemaPayloadLocation]>;
                totalPageCount: u64;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        sudo: {
            /**
             * The sudo key has been updated.
             **/
            KeyChanged: AugmentedEvent<ApiType, [old: Option<AccountId32>, new_: AccountId32], {
                old: Option<AccountId32>;
                new_: AccountId32;
            }>;
            /**
             * The key was permanently removed.
             **/
            KeyRemoved: AugmentedEvent<ApiType, []>;
            /**
             * A sudo call just took place.
             **/
            Sudid: AugmentedEvent<ApiType, [sudoResult: Result<Null, SpRuntimeDispatchError>], {
                sudoResult: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * A [sudo_as](Pallet::sudo_as) call just took place.
             **/
            SudoAsDone: AugmentedEvent<ApiType, [sudoResult: Result<Null, SpRuntimeDispatchError>], {
                sudoResult: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * 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>;
        };
        technicalCommittee: {
            /**
             * A motion was approved by the required threshold.
             **/
            Approved: AugmentedEvent<ApiType, [proposalHash: H256], {
                proposalHash: H256;
            }>;
            /**
             * A proposal was closed because its threshold was reached or after its duration was up.
             **/
            Closed: AugmentedEvent<ApiType, [proposalHash: H256, yes: u32, no: u32], {
                proposalHash: H256;
                yes: u32;
                no: u32;
            }>;
            /**
             * A motion was not approved by the required threshold.
             **/
            Disapproved: AugmentedEvent<ApiType, [proposalHash: H256], {
                proposalHash: H256;
            }>;
            /**
             * A motion was executed; result will be `Ok` if it returned without error.
             **/
            Executed: AugmentedEvent<ApiType, [proposalHash: H256, result: Result<Null, SpRuntimeDispatchError>], {
                proposalHash: H256;
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * A proposal was killed.
             **/
            Killed: AugmentedEvent<ApiType, [proposalHash: H256], {
                proposalHash: H256;
            }>;
            /**
             * A single member did some action; result will be `Ok` if it returned without error.
             **/
            MemberExecuted: AugmentedEvent<ApiType, [proposalHash: H256, result: Result<Null, SpRuntimeDispatchError>], {
                proposalHash: H256;
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * Some cost for storing a proposal was burned.
             **/
            ProposalCostBurned: AugmentedEvent<ApiType, [proposalHash: H256, who: AccountId32], {
                proposalHash: H256;
                who: AccountId32;
            }>;
            /**
             * Some cost for storing a proposal was released.
             **/
            ProposalCostReleased: AugmentedEvent<ApiType, [proposalHash: H256, who: AccountId32], {
                proposalHash: H256;
                who: AccountId32;
            }>;
            /**
             * A motion (given hash) has been proposed (by given account) with a threshold (given
             * `MemberCount`).
             **/
            Proposed: AugmentedEvent<ApiType, [account: AccountId32, proposalIndex: u32, proposalHash: H256, threshold: u32], {
                account: AccountId32;
                proposalIndex: u32;
                proposalHash: H256;
                threshold: u32;
            }>;
            /**
             * A motion (given hash) has been voted on by given account, leaving
             * a tally (yes votes and no votes given respectively as `MemberCount`).
             **/
            Voted: AugmentedEvent<ApiType, [account: AccountId32, proposalHash: H256, voted: bool, yes: u32, no: u32], {
                account: AccountId32;
                proposalHash: H256;
                voted: bool;
                yes: u32;
                no: u32;
            }>;
            /**
             * Generic event
             **/
            [key: string]: AugmentedEvent<ApiType>;
        };
        timeRelease: {
            /**
             * Claimed release.
             **/
            Claimed: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * Added new release schedule.
             **/
            ReleaseScheduleAdded: AugmentedEvent<ApiType, [from: AccountId32, to: AccountId32, releaseSchedule: PalletTimeReleaseReleaseSchedule], {
                from: AccountId32;
                to: AccountId32;
                releaseSchedule: PalletTimeReleaseReleaseSchedule;
            }>;
            /**
             * Updated release schedules.
             **/
            ReleaseSchedulesUpdated: AugmentedEvent<ApiType, [who: AccountId32], {
                who: AccountId32;
            }>;
            /**
             * 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: Null, amount: u128, beneficiary: AccountId32, validFrom: u32, expireAt: u32], {
                index: u32;
                assetKind: Null;
                amount: u128;
                beneficiary: AccountId32;
                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: Null], {
                index: u32;
                paymentId: Null;
            }>;
            /**
             * A payment failed and can be retried.
             **/
            PaymentFailed: AugmentedEvent<ApiType, [index: u32, paymentId: Null], {
                index: u32;
                paymentId: Null;
            }>;
            /**
             * New proposal.
             **/
            Proposed: AugmentedEvent<ApiType, [proposalIndex: u32], {
                proposalIndex: u32;
            }>;
            /**
             * A proposal was rejected; funds were slashed.
             **/
            Rejected: AugmentedEvent<ApiType, [proposalIndex: u32, slashed: u128], {
                proposalIndex: u32;
                slashed: u128;
            }>;
            /**
             * 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>;
        };
    }
}