@dedot/chaintypes 0.0.1-alpha.22

package/kusama/events.d.ts

@@ -0,0 +1,2960 @@
+import type { GenericChainEvents, GenericPalletEvent } from '@dedot/types';
+import type { DispatchInfo, DispatchError, AccountId32, H256, Perbill, FixedBytes, Bytes, Result, EthereumAddress, Perquintill, FixedU128 } from '@dedot/codecs';
+import type { FrameSupportTokensMiscBalanceStatus, PalletStakingRewardDestination, PalletStakingValidatorPrefs, PalletStakingForcing, SpConsensusGrandpaAppPublic, PalletImOnlineSr25519AppSr25519Public, PalletStakingExposure, PolkadotRuntimeCommonImplsVersionedLocatableAsset, XcmVersionedMultiLocation, FrameSupportPreimagesBounded, PalletConvictionVotingTally, PalletRankedCollectiveVoteRecord, PalletRankedCollectiveTally, FrameSupportDispatchPostDispatchInfo, SpRuntimeDispatchErrorWithPostInfo, PalletSocietyGroupParams, StagingKusamaRuntimeProxyType, PalletMultisigTimepoint, PalletElectionProviderMultiPhaseElectionCompute, SpNposElectionsElectionScore, PalletElectionProviderMultiPhasePhase, PalletNominationPoolsPoolState, PalletNominationPoolsCommissionChangeRate, PolkadotPrimitivesV6CandidateReceipt, PolkadotParachainPrimitivesPrimitivesHeadData, PolkadotPrimitivesV6CoreIndex, PolkadotPrimitivesV6GroupIndex, PolkadotParachainPrimitivesPrimitivesId, PolkadotParachainPrimitivesPrimitivesValidationCodeHash, PolkadotParachainPrimitivesPrimitivesHrmpChannelId, PolkadotCorePrimitivesCandidateHash, PolkadotRuntimeParachainsDisputesDisputeLocation, PolkadotRuntimeParachainsDisputesDisputeResult, PalletStateTrieMigrationMigrationCompute, PalletStateTrieMigrationError, XcmV3TraitsOutcome, StagingXcmV3MultilocationMultiLocation, XcmV3Xcm, XcmV3Response, SpWeightsWeightV2Weight, XcmVersionedMultiAssets, XcmV3MultiassetMultiAssets, XcmV3TraitsError, PolkadotRuntimeParachainsInclusionAggregateMessageOrigin, FrameSupportMessagesProcessMessageError } from './types';
+export interface ChainEvents extends GenericChainEvents {
+    /**
+     * Pallet `System`'s events
+     **/
+    system: {
+        /**
+         * An extrinsic completed successfully.
+         **/
+        ExtrinsicSuccess: GenericPalletEvent<'System', 'ExtrinsicSuccess', {
+            dispatchInfo: DispatchInfo;
+        }>;
+        /**
+         * An extrinsic failed.
+         **/
+        ExtrinsicFailed: GenericPalletEvent<'System', 'ExtrinsicFailed', {
+            dispatchError: DispatchError;
+            dispatchInfo: DispatchInfo;
+        }>;
+        /**
+         * `:code` was updated.
+         **/
+        CodeUpdated: GenericPalletEvent<'System', 'CodeUpdated', null>;
+        /**
+         * A new account was created.
+         **/
+        NewAccount: GenericPalletEvent<'System', 'NewAccount', {
+            account: AccountId32;
+        }>;
+        /**
+         * An account was reaped.
+         **/
+        KilledAccount: GenericPalletEvent<'System', 'KilledAccount', {
+            account: AccountId32;
+        }>;
+        /**
+         * On on-chain remark happened.
+         **/
+        Remarked: GenericPalletEvent<'System', 'Remarked', {
+            sender: AccountId32;
+            hash: H256;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Indices`'s events
+     **/
+    indices: {
+        /**
+         * A account index was assigned.
+         **/
+        IndexAssigned: GenericPalletEvent<'Indices', 'IndexAssigned', {
+            who: AccountId32;
+            index: number;
+        }>;
+        /**
+         * A account index has been freed up (unassigned).
+         **/
+        IndexFreed: GenericPalletEvent<'Indices', 'IndexFreed', {
+            index: number;
+        }>;
+        /**
+         * A account index has been frozen to its current account ID.
+         **/
+        IndexFrozen: GenericPalletEvent<'Indices', 'IndexFrozen', {
+            index: number;
+            who: AccountId32;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Balances`'s events
+     **/
+    balances: {
+        /**
+         * An account was created with some free balance.
+         **/
+        Endowed: GenericPalletEvent<'Balances', 'Endowed', {
+            account: AccountId32;
+            freeBalance: bigint;
+        }>;
+        /**
+         * An account was removed whose balance was non-zero but below ExistentialDeposit,
+         * resulting in an outright loss.
+         **/
+        DustLost: GenericPalletEvent<'Balances', 'DustLost', {
+            account: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Transfer succeeded.
+         **/
+        Transfer: GenericPalletEvent<'Balances', 'Transfer', {
+            from: AccountId32;
+            to: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * A balance was set by root.
+         **/
+        BalanceSet: GenericPalletEvent<'Balances', 'BalanceSet', {
+            who: AccountId32;
+            free: bigint;
+        }>;
+        /**
+         * Some balance was reserved (moved from free to reserved).
+         **/
+        Reserved: GenericPalletEvent<'Balances', 'Reserved', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some balance was unreserved (moved from reserved to free).
+         **/
+        Unreserved: GenericPalletEvent<'Balances', 'Unreserved', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some balance was moved from the reserve of the first account to the second account.
+         * Final argument indicates the destination balance type.
+         **/
+        ReserveRepatriated: GenericPalletEvent<'Balances', 'ReserveRepatriated', {
+            from: AccountId32;
+            to: AccountId32;
+            amount: bigint;
+            destinationStatus: FrameSupportTokensMiscBalanceStatus;
+        }>;
+        /**
+         * Some amount was deposited (e.g. for transaction fees).
+         **/
+        Deposit: GenericPalletEvent<'Balances', 'Deposit', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some amount was withdrawn from the account (e.g. for transaction fees).
+         **/
+        Withdraw: GenericPalletEvent<'Balances', 'Withdraw', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some amount was removed from the account (e.g. for misbehavior).
+         **/
+        Slashed: GenericPalletEvent<'Balances', 'Slashed', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some amount was minted into an account.
+         **/
+        Minted: GenericPalletEvent<'Balances', 'Minted', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some amount was burned from an account.
+         **/
+        Burned: GenericPalletEvent<'Balances', 'Burned', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some amount was suspended from an account (it can be restored later).
+         **/
+        Suspended: GenericPalletEvent<'Balances', 'Suspended', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some amount was restored into an account.
+         **/
+        Restored: GenericPalletEvent<'Balances', 'Restored', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An account was upgraded.
+         **/
+        Upgraded: GenericPalletEvent<'Balances', 'Upgraded', {
+            who: AccountId32;
+        }>;
+        /**
+         * Total issuance was increased by `amount`, creating a credit to be balanced.
+         **/
+        Issued: GenericPalletEvent<'Balances', 'Issued', {
+            amount: bigint;
+        }>;
+        /**
+         * Total issuance was decreased by `amount`, creating a debt to be balanced.
+         **/
+        Rescinded: GenericPalletEvent<'Balances', 'Rescinded', {
+            amount: bigint;
+        }>;
+        /**
+         * Some balance was locked.
+         **/
+        Locked: GenericPalletEvent<'Balances', 'Locked', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some balance was unlocked.
+         **/
+        Unlocked: GenericPalletEvent<'Balances', 'Unlocked', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some balance was frozen.
+         **/
+        Frozen: GenericPalletEvent<'Balances', 'Frozen', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some balance was thawed.
+         **/
+        Thawed: GenericPalletEvent<'Balances', 'Thawed', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `TransactionPayment`'s events
+     **/
+    transactionPayment: {
+        /**
+         * A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee,
+         * has been paid by `who`.
+         **/
+        TransactionFeePaid: GenericPalletEvent<'TransactionPayment', 'TransactionFeePaid', {
+            who: AccountId32;
+            actualFee: bigint;
+            tip: bigint;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Staking`'s events
+     **/
+    staking: {
+        /**
+         * 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: GenericPalletEvent<'Staking', 'EraPaid', {
+            eraIndex: number;
+            validatorPayout: bigint;
+            remainder: bigint;
+        }>;
+        /**
+         * The nominator has been rewarded by this amount to this destination.
+         **/
+        Rewarded: GenericPalletEvent<'Staking', 'Rewarded', {
+            stash: AccountId32;
+            dest: PalletStakingRewardDestination;
+            amount: bigint;
+        }>;
+        /**
+         * A staker (validator or nominator) has been slashed by the given amount.
+         **/
+        Slashed: GenericPalletEvent<'Staking', 'Slashed', {
+            staker: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * A slash for the given validator, for the given percentage of their stake, at the given
+         * era as been reported.
+         **/
+        SlashReported: GenericPalletEvent<'Staking', 'SlashReported', {
+            validator: AccountId32;
+            fraction: Perbill;
+            slashEra: number;
+        }>;
+        /**
+         * An old slashing report from a prior era was discarded because it could
+         * not be processed.
+         **/
+        OldSlashingReportDiscarded: GenericPalletEvent<'Staking', 'OldSlashingReportDiscarded', {
+            sessionIndex: number;
+        }>;
+        /**
+         * A new set of stakers was elected.
+         **/
+        StakersElected: GenericPalletEvent<'Staking', 'StakersElected', null>;
+        /**
+         * 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: GenericPalletEvent<'Staking', 'Bonded', {
+            stash: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An account has unbonded this amount.
+         **/
+        Unbonded: GenericPalletEvent<'Staking', 'Unbonded', {
+            stash: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An account has called `withdraw_unbonded` and removed unbonding chunks worth `Balance`
+         * from the unlocking queue.
+         **/
+        Withdrawn: GenericPalletEvent<'Staking', 'Withdrawn', {
+            stash: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * A nominator has been kicked from a validator.
+         **/
+        Kicked: GenericPalletEvent<'Staking', 'Kicked', {
+            nominator: AccountId32;
+            stash: AccountId32;
+        }>;
+        /**
+         * The election failed. No new era is planned.
+         **/
+        StakingElectionFailed: GenericPalletEvent<'Staking', 'StakingElectionFailed', null>;
+        /**
+         * An account has stopped participating as either a validator or nominator.
+         **/
+        Chilled: GenericPalletEvent<'Staking', 'Chilled', {
+            stash: AccountId32;
+        }>;
+        /**
+         * The stakers' rewards are getting paid.
+         **/
+        PayoutStarted: GenericPalletEvent<'Staking', 'PayoutStarted', {
+            eraIndex: number;
+            validatorStash: AccountId32;
+        }>;
+        /**
+         * A validator has set their preferences.
+         **/
+        ValidatorPrefsSet: GenericPalletEvent<'Staking', 'ValidatorPrefsSet', {
+            stash: AccountId32;
+            prefs: PalletStakingValidatorPrefs;
+        }>;
+        /**
+         * Voters size limit reached.
+         **/
+        SnapshotVotersSizeExceeded: GenericPalletEvent<'Staking', 'SnapshotVotersSizeExceeded', {
+            size: number;
+        }>;
+        /**
+         * Targets size limit reached.
+         **/
+        SnapshotTargetsSizeExceeded: GenericPalletEvent<'Staking', 'SnapshotTargetsSizeExceeded', {
+            size: number;
+        }>;
+        /**
+         * A new force era mode was set.
+         **/
+        ForceEra: GenericPalletEvent<'Staking', 'ForceEra', {
+            mode: PalletStakingForcing;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Offences`'s events
+     **/
+    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: GenericPalletEvent<'Offences', 'Offence', {
+            kind: FixedBytes<16>;
+            timeslot: Bytes;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Session`'s events
+     **/
+    session: {
+        /**
+         * New session has happened. Note that the argument is the session index, not the
+         * block number as the type might suggest.
+         **/
+        NewSession: GenericPalletEvent<'Session', 'NewSession', {
+            sessionIndex: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Grandpa`'s events
+     **/
+    grandpa: {
+        /**
+         * New authority set has been applied.
+         **/
+        NewAuthorities: GenericPalletEvent<'Grandpa', 'NewAuthorities', {
+            authoritySet: Array<[SpConsensusGrandpaAppPublic, bigint]>;
+        }>;
+        /**
+         * Current authority set has been paused.
+         **/
+        Paused: GenericPalletEvent<'Grandpa', 'Paused', null>;
+        /**
+         * Current authority set has been resumed.
+         **/
+        Resumed: GenericPalletEvent<'Grandpa', 'Resumed', null>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `ImOnline`'s events
+     **/
+    imOnline: {
+        /**
+         * A new heartbeat was received from `AuthorityId`.
+         **/
+        HeartbeatReceived: GenericPalletEvent<'ImOnline', 'HeartbeatReceived', {
+            authorityId: PalletImOnlineSr25519AppSr25519Public;
+        }>;
+        /**
+         * At the end of the session, no offence was committed.
+         **/
+        AllGood: GenericPalletEvent<'ImOnline', 'AllGood', null>;
+        /**
+         * At the end of the session, at least one validator was found to be offline.
+         **/
+        SomeOffline: GenericPalletEvent<'ImOnline', 'SomeOffline', {
+            offline: Array<[AccountId32, PalletStakingExposure]>;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Treasury`'s events
+     **/
+    treasury: {
+        /**
+         * New proposal.
+         **/
+        Proposed: GenericPalletEvent<'Treasury', 'Proposed', {
+            proposalIndex: number;
+        }>;
+        /**
+         * We have ended a spend period and will now allocate funds.
+         **/
+        Spending: GenericPalletEvent<'Treasury', 'Spending', {
+            budgetRemaining: bigint;
+        }>;
+        /**
+         * Some funds have been allocated.
+         **/
+        Awarded: GenericPalletEvent<'Treasury', 'Awarded', {
+            proposalIndex: number;
+            award: bigint;
+            account: AccountId32;
+        }>;
+        /**
+         * A proposal was rejected; funds were slashed.
+         **/
+        Rejected: GenericPalletEvent<'Treasury', 'Rejected', {
+            proposalIndex: number;
+            slashed: bigint;
+        }>;
+        /**
+         * Some of our funds have been burnt.
+         **/
+        Burnt: GenericPalletEvent<'Treasury', 'Burnt', {
+            burntFunds: bigint;
+        }>;
+        /**
+         * Spending has finished; this is the amount that rolls over until next spend.
+         **/
+        Rollover: GenericPalletEvent<'Treasury', 'Rollover', {
+            rolloverBalance: bigint;
+        }>;
+        /**
+         * Some funds have been deposited.
+         **/
+        Deposit: GenericPalletEvent<'Treasury', 'Deposit', {
+            value: bigint;
+        }>;
+        /**
+         * A new spend proposal has been approved.
+         **/
+        SpendApproved: GenericPalletEvent<'Treasury', 'SpendApproved', {
+            proposalIndex: number;
+            amount: bigint;
+            beneficiary: AccountId32;
+        }>;
+        /**
+         * The inactive funds of the pallet have been updated.
+         **/
+        UpdatedInactive: GenericPalletEvent<'Treasury', 'UpdatedInactive', {
+            reactivated: bigint;
+            deactivated: bigint;
+        }>;
+        /**
+         * A new asset spend proposal has been approved.
+         **/
+        AssetSpendApproved: GenericPalletEvent<'Treasury', 'AssetSpendApproved', {
+            index: number;
+            assetKind: PolkadotRuntimeCommonImplsVersionedLocatableAsset;
+            amount: bigint;
+            beneficiary: XcmVersionedMultiLocation;
+            validFrom: number;
+            expireAt: number;
+        }>;
+        /**
+         * An approved spend was voided.
+         **/
+        AssetSpendVoided: GenericPalletEvent<'Treasury', 'AssetSpendVoided', {
+            index: number;
+        }>;
+        /**
+         * A payment happened.
+         **/
+        Paid: GenericPalletEvent<'Treasury', 'Paid', {
+            index: number;
+            paymentId: bigint;
+        }>;
+        /**
+         * A payment failed and can be retried.
+         **/
+        PaymentFailed: GenericPalletEvent<'Treasury', 'PaymentFailed', {
+            index: number;
+            paymentId: bigint;
+        }>;
+        /**
+         * A spend was processed and removed from the storage. It might have been successfully
+         * paid or it may have expired.
+         **/
+        SpendProcessed: GenericPalletEvent<'Treasury', 'SpendProcessed', {
+            index: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `ConvictionVoting`'s events
+     **/
+    convictionVoting: {
+        /**
+         * An account has delegated their vote to another account. \[who, target\]
+         **/
+        Delegated: GenericPalletEvent<'ConvictionVoting', 'Delegated', [AccountId32, AccountId32]>;
+        /**
+         * An \[account\] has cancelled a previous delegation operation.
+         **/
+        Undelegated: GenericPalletEvent<'ConvictionVoting', 'Undelegated', AccountId32>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Referenda`'s events
+     **/
+    referenda: {
+        /**
+         * A referendum has been submitted.
+         **/
+        Submitted: GenericPalletEvent<'Referenda', 'Submitted', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The track (and by extension proposal dispatch origin) of this referendum.
+             **/
+            track: number;
+            /**
+             * The proposal for the referendum.
+             **/
+            proposal: FrameSupportPreimagesBounded;
+        }>;
+        /**
+         * The decision deposit has been placed.
+         **/
+        DecisionDepositPlaced: GenericPalletEvent<'Referenda', 'DecisionDepositPlaced', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The account who placed the deposit.
+             **/
+            who: AccountId32;
+            /**
+             * The amount placed by the account.
+             **/
+            amount: bigint;
+        }>;
+        /**
+         * The decision deposit has been refunded.
+         **/
+        DecisionDepositRefunded: GenericPalletEvent<'Referenda', 'DecisionDepositRefunded', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The account who placed the deposit.
+             **/
+            who: AccountId32;
+            /**
+             * The amount placed by the account.
+             **/
+            amount: bigint;
+        }>;
+        /**
+         * A deposit has been slashaed.
+         **/
+        DepositSlashed: GenericPalletEvent<'Referenda', 'DepositSlashed', {
+            /**
+             * The account who placed the deposit.
+             **/
+            who: AccountId32;
+            /**
+             * The amount placed by the account.
+             **/
+            amount: bigint;
+        }>;
+        /**
+         * A referendum has moved into the deciding phase.
+         **/
+        DecisionStarted: GenericPalletEvent<'Referenda', 'DecisionStarted', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The track (and by extension proposal dispatch origin) of this referendum.
+             **/
+            track: number;
+            /**
+             * The proposal for the referendum.
+             **/
+            proposal: FrameSupportPreimagesBounded;
+            /**
+             * The current tally of votes in this referendum.
+             **/
+            tally: PalletConvictionVotingTally;
+        }>;
+        ConfirmStarted: GenericPalletEvent<'Referenda', 'ConfirmStarted', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+        }>;
+        ConfirmAborted: GenericPalletEvent<'Referenda', 'ConfirmAborted', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+        }>;
+        /**
+         * A referendum has ended its confirmation phase and is ready for approval.
+         **/
+        Confirmed: GenericPalletEvent<'Referenda', 'Confirmed', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The final tally of votes in this referendum.
+             **/
+            tally: PalletConvictionVotingTally;
+        }>;
+        /**
+         * A referendum has been approved and its proposal has been scheduled.
+         **/
+        Approved: GenericPalletEvent<'Referenda', 'Approved', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+        }>;
+        /**
+         * A proposal has been rejected by referendum.
+         **/
+        Rejected: GenericPalletEvent<'Referenda', 'Rejected', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The final tally of votes in this referendum.
+             **/
+            tally: PalletConvictionVotingTally;
+        }>;
+        /**
+         * A referendum has been timed out without being decided.
+         **/
+        TimedOut: GenericPalletEvent<'Referenda', 'TimedOut', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The final tally of votes in this referendum.
+             **/
+            tally: PalletConvictionVotingTally;
+        }>;
+        /**
+         * A referendum has been cancelled.
+         **/
+        Cancelled: GenericPalletEvent<'Referenda', 'Cancelled', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The final tally of votes in this referendum.
+             **/
+            tally: PalletConvictionVotingTally;
+        }>;
+        /**
+         * A referendum has been killed.
+         **/
+        Killed: GenericPalletEvent<'Referenda', 'Killed', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The final tally of votes in this referendum.
+             **/
+            tally: PalletConvictionVotingTally;
+        }>;
+        /**
+         * The submission deposit has been refunded.
+         **/
+        SubmissionDepositRefunded: GenericPalletEvent<'Referenda', 'SubmissionDepositRefunded', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The account who placed the deposit.
+             **/
+            who: AccountId32;
+            /**
+             * The amount placed by the account.
+             **/
+            amount: bigint;
+        }>;
+        /**
+         * Metadata for a referendum has been set.
+         **/
+        MetadataSet: GenericPalletEvent<'Referenda', 'MetadataSet', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * Preimage hash.
+             **/
+            hash: H256;
+        }>;
+        /**
+         * Metadata for a referendum has been cleared.
+         **/
+        MetadataCleared: GenericPalletEvent<'Referenda', 'MetadataCleared', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * Preimage hash.
+             **/
+            hash: H256;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `FellowshipCollective`'s events
+     **/
+    fellowshipCollective: {
+        /**
+         * A member `who` has been added.
+         **/
+        MemberAdded: GenericPalletEvent<'FellowshipCollective', 'MemberAdded', {
+            who: AccountId32;
+        }>;
+        /**
+         * The member `who`se rank has been changed to the given `rank`.
+         **/
+        RankChanged: GenericPalletEvent<'FellowshipCollective', 'RankChanged', {
+            who: AccountId32;
+            rank: number;
+        }>;
+        /**
+         * The member `who` of given `rank` has been removed from the collective.
+         **/
+        MemberRemoved: GenericPalletEvent<'FellowshipCollective', 'MemberRemoved', {
+            who: AccountId32;
+            rank: number;
+        }>;
+        /**
+         * The member `who` has voted for the `poll` with the given `vote` leading to an updated
+         * `tally`.
+         **/
+        Voted: GenericPalletEvent<'FellowshipCollective', 'Voted', {
+            who: AccountId32;
+            poll: number;
+            vote: PalletRankedCollectiveVoteRecord;
+            tally: PalletRankedCollectiveTally;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `FellowshipReferenda`'s events
+     **/
+    fellowshipReferenda: {
+        /**
+         * A referendum has been submitted.
+         **/
+        Submitted: GenericPalletEvent<'FellowshipReferenda', 'Submitted', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The track (and by extension proposal dispatch origin) of this referendum.
+             **/
+            track: number;
+            /**
+             * The proposal for the referendum.
+             **/
+            proposal: FrameSupportPreimagesBounded;
+        }>;
+        /**
+         * The decision deposit has been placed.
+         **/
+        DecisionDepositPlaced: GenericPalletEvent<'FellowshipReferenda', 'DecisionDepositPlaced', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The account who placed the deposit.
+             **/
+            who: AccountId32;
+            /**
+             * The amount placed by the account.
+             **/
+            amount: bigint;
+        }>;
+        /**
+         * The decision deposit has been refunded.
+         **/
+        DecisionDepositRefunded: GenericPalletEvent<'FellowshipReferenda', 'DecisionDepositRefunded', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The account who placed the deposit.
+             **/
+            who: AccountId32;
+            /**
+             * The amount placed by the account.
+             **/
+            amount: bigint;
+        }>;
+        /**
+         * A deposit has been slashaed.
+         **/
+        DepositSlashed: GenericPalletEvent<'FellowshipReferenda', 'DepositSlashed', {
+            /**
+             * The account who placed the deposit.
+             **/
+            who: AccountId32;
+            /**
+             * The amount placed by the account.
+             **/
+            amount: bigint;
+        }>;
+        /**
+         * A referendum has moved into the deciding phase.
+         **/
+        DecisionStarted: GenericPalletEvent<'FellowshipReferenda', 'DecisionStarted', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The track (and by extension proposal dispatch origin) of this referendum.
+             **/
+            track: number;
+            /**
+             * The proposal for the referendum.
+             **/
+            proposal: FrameSupportPreimagesBounded;
+            /**
+             * The current tally of votes in this referendum.
+             **/
+            tally: PalletRankedCollectiveTally;
+        }>;
+        ConfirmStarted: GenericPalletEvent<'FellowshipReferenda', 'ConfirmStarted', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+        }>;
+        ConfirmAborted: GenericPalletEvent<'FellowshipReferenda', 'ConfirmAborted', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+        }>;
+        /**
+         * A referendum has ended its confirmation phase and is ready for approval.
+         **/
+        Confirmed: GenericPalletEvent<'FellowshipReferenda', 'Confirmed', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The final tally of votes in this referendum.
+             **/
+            tally: PalletRankedCollectiveTally;
+        }>;
+        /**
+         * A referendum has been approved and its proposal has been scheduled.
+         **/
+        Approved: GenericPalletEvent<'FellowshipReferenda', 'Approved', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+        }>;
+        /**
+         * A proposal has been rejected by referendum.
+         **/
+        Rejected: GenericPalletEvent<'FellowshipReferenda', 'Rejected', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The final tally of votes in this referendum.
+             **/
+            tally: PalletRankedCollectiveTally;
+        }>;
+        /**
+         * A referendum has been timed out without being decided.
+         **/
+        TimedOut: GenericPalletEvent<'FellowshipReferenda', 'TimedOut', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The final tally of votes in this referendum.
+             **/
+            tally: PalletRankedCollectiveTally;
+        }>;
+        /**
+         * A referendum has been cancelled.
+         **/
+        Cancelled: GenericPalletEvent<'FellowshipReferenda', 'Cancelled', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The final tally of votes in this referendum.
+             **/
+            tally: PalletRankedCollectiveTally;
+        }>;
+        /**
+         * A referendum has been killed.
+         **/
+        Killed: GenericPalletEvent<'FellowshipReferenda', 'Killed', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The final tally of votes in this referendum.
+             **/
+            tally: PalletRankedCollectiveTally;
+        }>;
+        /**
+         * The submission deposit has been refunded.
+         **/
+        SubmissionDepositRefunded: GenericPalletEvent<'FellowshipReferenda', 'SubmissionDepositRefunded', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The account who placed the deposit.
+             **/
+            who: AccountId32;
+            /**
+             * The amount placed by the account.
+             **/
+            amount: bigint;
+        }>;
+        /**
+         * Metadata for a referendum has been set.
+         **/
+        MetadataSet: GenericPalletEvent<'FellowshipReferenda', 'MetadataSet', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * Preimage hash.
+             **/
+            hash: H256;
+        }>;
+        /**
+         * Metadata for a referendum has been cleared.
+         **/
+        MetadataCleared: GenericPalletEvent<'FellowshipReferenda', 'MetadataCleared', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * Preimage hash.
+             **/
+            hash: H256;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Whitelist`'s events
+     **/
+    whitelist: {
+        CallWhitelisted: GenericPalletEvent<'Whitelist', 'CallWhitelisted', {
+            callHash: H256;
+        }>;
+        WhitelistedCallRemoved: GenericPalletEvent<'Whitelist', 'WhitelistedCallRemoved', {
+            callHash: H256;
+        }>;
+        WhitelistedCallDispatched: GenericPalletEvent<'Whitelist', 'WhitelistedCallDispatched', {
+            callHash: H256;
+            result: Result<FrameSupportDispatchPostDispatchInfo, SpRuntimeDispatchErrorWithPostInfo>;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Claims`'s events
+     **/
+    claims: {
+        /**
+         * Someone claimed some DOTs.
+         **/
+        Claimed: GenericPalletEvent<'Claims', 'Claimed', {
+            who: AccountId32;
+            ethereumAddress: EthereumAddress;
+            amount: bigint;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Utility`'s events
+     **/
+    utility: {
+        /**
+         * Batch of dispatches did not complete fully. Index of first failing dispatch given, as
+         * well as the error.
+         **/
+        BatchInterrupted: GenericPalletEvent<'Utility', 'BatchInterrupted', {
+            index: number;
+            error: DispatchError;
+        }>;
+        /**
+         * Batch of dispatches completed fully with no error.
+         **/
+        BatchCompleted: GenericPalletEvent<'Utility', 'BatchCompleted', null>;
+        /**
+         * Batch of dispatches completed but has errors.
+         **/
+        BatchCompletedWithErrors: GenericPalletEvent<'Utility', 'BatchCompletedWithErrors', null>;
+        /**
+         * A single item within a Batch of dispatches has completed with no error.
+         **/
+        ItemCompleted: GenericPalletEvent<'Utility', 'ItemCompleted', null>;
+        /**
+         * A single item within a Batch of dispatches has completed with error.
+         **/
+        ItemFailed: GenericPalletEvent<'Utility', 'ItemFailed', {
+            error: DispatchError;
+        }>;
+        /**
+         * A call was dispatched.
+         **/
+        DispatchedAs: GenericPalletEvent<'Utility', 'DispatchedAs', {
+            result: Result<[], DispatchError>;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Identity`'s events
+     **/
+    identity: {
+        /**
+         * A name was set or reset (which will remove all judgements).
+         **/
+        IdentitySet: GenericPalletEvent<'Identity', 'IdentitySet', {
+            who: AccountId32;
+        }>;
+        /**
+         * A name was cleared, and the given balance returned.
+         **/
+        IdentityCleared: GenericPalletEvent<'Identity', 'IdentityCleared', {
+            who: AccountId32;
+            deposit: bigint;
+        }>;
+        /**
+         * A name was removed and the given balance slashed.
+         **/
+        IdentityKilled: GenericPalletEvent<'Identity', 'IdentityKilled', {
+            who: AccountId32;
+            deposit: bigint;
+        }>;
+        /**
+         * A judgement was asked from a registrar.
+         **/
+        JudgementRequested: GenericPalletEvent<'Identity', 'JudgementRequested', {
+            who: AccountId32;
+            registrarIndex: number;
+        }>;
+        /**
+         * A judgement request was retracted.
+         **/
+        JudgementUnrequested: GenericPalletEvent<'Identity', 'JudgementUnrequested', {
+            who: AccountId32;
+            registrarIndex: number;
+        }>;
+        /**
+         * A judgement was given by a registrar.
+         **/
+        JudgementGiven: GenericPalletEvent<'Identity', 'JudgementGiven', {
+            target: AccountId32;
+            registrarIndex: number;
+        }>;
+        /**
+         * A registrar was added.
+         **/
+        RegistrarAdded: GenericPalletEvent<'Identity', 'RegistrarAdded', {
+            registrarIndex: number;
+        }>;
+        /**
+         * A sub-identity was added to an identity and the deposit paid.
+         **/
+        SubIdentityAdded: GenericPalletEvent<'Identity', 'SubIdentityAdded', {
+            sub: AccountId32;
+            main: AccountId32;
+            deposit: bigint;
+        }>;
+        /**
+         * A sub-identity was removed from an identity and the deposit freed.
+         **/
+        SubIdentityRemoved: GenericPalletEvent<'Identity', 'SubIdentityRemoved', {
+            sub: AccountId32;
+            main: AccountId32;
+            deposit: bigint;
+        }>;
+        /**
+         * A sub-identity was cleared, and the given deposit repatriated from the
+         * main identity account to the sub-identity account.
+         **/
+        SubIdentityRevoked: GenericPalletEvent<'Identity', 'SubIdentityRevoked', {
+            sub: AccountId32;
+            main: AccountId32;
+            deposit: bigint;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Society`'s events
+     **/
+    society: {
+        /**
+         * The society is founded by the given identity.
+         **/
+        Founded: GenericPalletEvent<'Society', 'Founded', {
+            founder: AccountId32;
+        }>;
+        /**
+         * A membership bid just happened. The given account is the candidate's ID and their offer
+         * is the second.
+         **/
+        Bid: GenericPalletEvent<'Society', 'Bid', {
+            candidateId: AccountId32;
+            offer: bigint;
+        }>;
+        /**
+         * A membership bid just happened by vouching. The given account is the candidate's ID and
+         * their offer is the second. The vouching party is the third.
+         **/
+        Vouch: GenericPalletEvent<'Society', 'Vouch', {
+            candidateId: AccountId32;
+            offer: bigint;
+            vouching: AccountId32;
+        }>;
+        /**
+         * A candidate was dropped (due to an excess of bids in the system).
+         **/
+        AutoUnbid: GenericPalletEvent<'Society', 'AutoUnbid', {
+            candidate: AccountId32;
+        }>;
+        /**
+         * A candidate was dropped (by their request).
+         **/
+        Unbid: GenericPalletEvent<'Society', 'Unbid', {
+            candidate: AccountId32;
+        }>;
+        /**
+         * A candidate was dropped (by request of who vouched for them).
+         **/
+        Unvouch: GenericPalletEvent<'Society', 'Unvouch', {
+            candidate: AccountId32;
+        }>;
+        /**
+         * A group of candidates have been inducted. The batch's primary is the first value, the
+         * batch in full is the second.
+         **/
+        Inducted: GenericPalletEvent<'Society', 'Inducted', {
+            primary: AccountId32;
+            candidates: Array<AccountId32>;
+        }>;
+        /**
+         * A suspended member has been judged.
+         **/
+        SuspendedMemberJudgement: GenericPalletEvent<'Society', 'SuspendedMemberJudgement', {
+            who: AccountId32;
+            judged: boolean;
+        }>;
+        /**
+         * A candidate has been suspended
+         **/
+        CandidateSuspended: GenericPalletEvent<'Society', 'CandidateSuspended', {
+            candidate: AccountId32;
+        }>;
+        /**
+         * A member has been suspended
+         **/
+        MemberSuspended: GenericPalletEvent<'Society', 'MemberSuspended', {
+            member: AccountId32;
+        }>;
+        /**
+         * A member has been challenged
+         **/
+        Challenged: GenericPalletEvent<'Society', 'Challenged', {
+            member: AccountId32;
+        }>;
+        /**
+         * A vote has been placed
+         **/
+        Vote: GenericPalletEvent<'Society', 'Vote', {
+            candidate: AccountId32;
+            voter: AccountId32;
+            vote: boolean;
+        }>;
+        /**
+         * A vote has been placed for a defending member
+         **/
+        DefenderVote: GenericPalletEvent<'Society', 'DefenderVote', {
+            voter: AccountId32;
+            vote: boolean;
+        }>;
+        /**
+         * A new set of \[params\] has been set for the group.
+         **/
+        NewParams: GenericPalletEvent<'Society', 'NewParams', {
+            params: PalletSocietyGroupParams;
+        }>;
+        /**
+         * Society is unfounded.
+         **/
+        Unfounded: GenericPalletEvent<'Society', 'Unfounded', {
+            founder: AccountId32;
+        }>;
+        /**
+         * Some funds were deposited into the society account.
+         **/
+        Deposit: GenericPalletEvent<'Society', 'Deposit', {
+            value: bigint;
+        }>;
+        /**
+         * A \[member\] got elevated to \[rank\].
+         **/
+        Elevated: GenericPalletEvent<'Society', 'Elevated', {
+            member: AccountId32;
+            rank: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Recovery`'s events
+     **/
+    recovery: {
+        /**
+         * A recovery process has been set up for an account.
+         **/
+        RecoveryCreated: GenericPalletEvent<'Recovery', 'RecoveryCreated', {
+            account: AccountId32;
+        }>;
+        /**
+         * A recovery process has been initiated for lost account by rescuer account.
+         **/
+        RecoveryInitiated: GenericPalletEvent<'Recovery', 'RecoveryInitiated', {
+            lostAccount: AccountId32;
+            rescuerAccount: AccountId32;
+        }>;
+        /**
+         * A recovery process for lost account by rescuer account has been vouched for by sender.
+         **/
+        RecoveryVouched: GenericPalletEvent<'Recovery', 'RecoveryVouched', {
+            lostAccount: AccountId32;
+            rescuerAccount: AccountId32;
+            sender: AccountId32;
+        }>;
+        /**
+         * A recovery process for lost account by rescuer account has been closed.
+         **/
+        RecoveryClosed: GenericPalletEvent<'Recovery', 'RecoveryClosed', {
+            lostAccount: AccountId32;
+            rescuerAccount: AccountId32;
+        }>;
+        /**
+         * Lost account has been successfully recovered by rescuer account.
+         **/
+        AccountRecovered: GenericPalletEvent<'Recovery', 'AccountRecovered', {
+            lostAccount: AccountId32;
+            rescuerAccount: AccountId32;
+        }>;
+        /**
+         * A recovery process has been removed for an account.
+         **/
+        RecoveryRemoved: GenericPalletEvent<'Recovery', 'RecoveryRemoved', {
+            lostAccount: AccountId32;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Vesting`'s events
+     **/
+    vesting: {
+        /**
+         * 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: GenericPalletEvent<'Vesting', 'VestingUpdated', {
+            account: AccountId32;
+            unvested: bigint;
+        }>;
+        /**
+         * An \[account\] has become fully vested.
+         **/
+        VestingCompleted: GenericPalletEvent<'Vesting', 'VestingCompleted', {
+            account: AccountId32;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Scheduler`'s events
+     **/
+    scheduler: {
+        /**
+         * Scheduled some task.
+         **/
+        Scheduled: GenericPalletEvent<'Scheduler', 'Scheduled', {
+            when: number;
+            index: number;
+        }>;
+        /**
+         * Canceled some task.
+         **/
+        Canceled: GenericPalletEvent<'Scheduler', 'Canceled', {
+            when: number;
+            index: number;
+        }>;
+        /**
+         * Dispatched some task.
+         **/
+        Dispatched: GenericPalletEvent<'Scheduler', 'Dispatched', {
+            task: [number, number];
+            id?: FixedBytes<32> | undefined;
+            result: Result<[], DispatchError>;
+        }>;
+        /**
+         * The call for the provided hash was not found so the task has been aborted.
+         **/
+        CallUnavailable: GenericPalletEvent<'Scheduler', 'CallUnavailable', {
+            task: [number, number];
+            id?: FixedBytes<32> | undefined;
+        }>;
+        /**
+         * The given task was unable to be renewed since the agenda is full at that block.
+         **/
+        PeriodicFailed: GenericPalletEvent<'Scheduler', 'PeriodicFailed', {
+            task: [number, number];
+            id?: FixedBytes<32> | undefined;
+        }>;
+        /**
+         * The given task can never be executed since it is overweight.
+         **/
+        PermanentlyOverweight: GenericPalletEvent<'Scheduler', 'PermanentlyOverweight', {
+            task: [number, number];
+            id?: FixedBytes<32> | undefined;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Proxy`'s events
+     **/
+    proxy: {
+        /**
+         * A proxy was executed correctly, with the given.
+         **/
+        ProxyExecuted: GenericPalletEvent<'Proxy', 'ProxyExecuted', {
+            result: Result<[], DispatchError>;
+        }>;
+        /**
+         * A pure account has been created by new proxy with given
+         * disambiguation index and proxy type.
+         **/
+        PureCreated: GenericPalletEvent<'Proxy', 'PureCreated', {
+            pure: AccountId32;
+            who: AccountId32;
+            proxyType: StagingKusamaRuntimeProxyType;
+            disambiguationIndex: number;
+        }>;
+        /**
+         * An announcement was placed to make a call in the future.
+         **/
+        Announced: GenericPalletEvent<'Proxy', 'Announced', {
+            real: AccountId32;
+            proxy: AccountId32;
+            callHash: H256;
+        }>;
+        /**
+         * A proxy was added.
+         **/
+        ProxyAdded: GenericPalletEvent<'Proxy', 'ProxyAdded', {
+            delegator: AccountId32;
+            delegatee: AccountId32;
+            proxyType: StagingKusamaRuntimeProxyType;
+            delay: number;
+        }>;
+        /**
+         * A proxy was removed.
+         **/
+        ProxyRemoved: GenericPalletEvent<'Proxy', 'ProxyRemoved', {
+            delegator: AccountId32;
+            delegatee: AccountId32;
+            proxyType: StagingKusamaRuntimeProxyType;
+            delay: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Multisig`'s events
+     **/
+    multisig: {
+        /**
+         * A new multisig operation has begun.
+         **/
+        NewMultisig: GenericPalletEvent<'Multisig', 'NewMultisig', {
+            approving: AccountId32;
+            multisig: AccountId32;
+            callHash: FixedBytes<32>;
+        }>;
+        /**
+         * A multisig operation has been approved by someone.
+         **/
+        MultisigApproval: GenericPalletEvent<'Multisig', 'MultisigApproval', {
+            approving: AccountId32;
+            timepoint: PalletMultisigTimepoint;
+            multisig: AccountId32;
+            callHash: FixedBytes<32>;
+        }>;
+        /**
+         * A multisig operation has been executed.
+         **/
+        MultisigExecuted: GenericPalletEvent<'Multisig', 'MultisigExecuted', {
+            approving: AccountId32;
+            timepoint: PalletMultisigTimepoint;
+            multisig: AccountId32;
+            callHash: FixedBytes<32>;
+            result: Result<[], DispatchError>;
+        }>;
+        /**
+         * A multisig operation has been cancelled.
+         **/
+        MultisigCancelled: GenericPalletEvent<'Multisig', 'MultisigCancelled', {
+            cancelling: AccountId32;
+            timepoint: PalletMultisigTimepoint;
+            multisig: AccountId32;
+            callHash: FixedBytes<32>;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Preimage`'s events
+     **/
+    preimage: {
+        /**
+         * A preimage has been noted.
+         **/
+        Noted: GenericPalletEvent<'Preimage', 'Noted', {
+            hash: H256;
+        }>;
+        /**
+         * A preimage has been requested.
+         **/
+        Requested: GenericPalletEvent<'Preimage', 'Requested', {
+            hash: H256;
+        }>;
+        /**
+         * A preimage has ben cleared.
+         **/
+        Cleared: GenericPalletEvent<'Preimage', 'Cleared', {
+            hash: H256;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Bounties`'s events
+     **/
+    bounties: {
+        /**
+         * New bounty proposal.
+         **/
+        BountyProposed: GenericPalletEvent<'Bounties', 'BountyProposed', {
+            index: number;
+        }>;
+        /**
+         * A bounty proposal was rejected; funds were slashed.
+         **/
+        BountyRejected: GenericPalletEvent<'Bounties', 'BountyRejected', {
+            index: number;
+            bond: bigint;
+        }>;
+        /**
+         * A bounty proposal is funded and became active.
+         **/
+        BountyBecameActive: GenericPalletEvent<'Bounties', 'BountyBecameActive', {
+            index: number;
+        }>;
+        /**
+         * A bounty is awarded to a beneficiary.
+         **/
+        BountyAwarded: GenericPalletEvent<'Bounties', 'BountyAwarded', {
+            index: number;
+            beneficiary: AccountId32;
+        }>;
+        /**
+         * A bounty is claimed by beneficiary.
+         **/
+        BountyClaimed: GenericPalletEvent<'Bounties', 'BountyClaimed', {
+            index: number;
+            payout: bigint;
+            beneficiary: AccountId32;
+        }>;
+        /**
+         * A bounty is cancelled.
+         **/
+        BountyCanceled: GenericPalletEvent<'Bounties', 'BountyCanceled', {
+            index: number;
+        }>;
+        /**
+         * A bounty expiry is extended.
+         **/
+        BountyExtended: GenericPalletEvent<'Bounties', 'BountyExtended', {
+            index: number;
+        }>;
+        /**
+         * A bounty is approved.
+         **/
+        BountyApproved: GenericPalletEvent<'Bounties', 'BountyApproved', {
+            index: number;
+        }>;
+        /**
+         * A bounty curator is proposed.
+         **/
+        CuratorProposed: GenericPalletEvent<'Bounties', 'CuratorProposed', {
+            bountyId: number;
+            curator: AccountId32;
+        }>;
+        /**
+         * A bounty curator is unassigned.
+         **/
+        CuratorUnassigned: GenericPalletEvent<'Bounties', 'CuratorUnassigned', {
+            bountyId: number;
+        }>;
+        /**
+         * A bounty curator is accepted.
+         **/
+        CuratorAccepted: GenericPalletEvent<'Bounties', 'CuratorAccepted', {
+            bountyId: number;
+            curator: AccountId32;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `ChildBounties`'s events
+     **/
+    childBounties: {
+        /**
+         * A child-bounty is added.
+         **/
+        Added: GenericPalletEvent<'ChildBounties', 'Added', {
+            index: number;
+            childIndex: number;
+        }>;
+        /**
+         * A child-bounty is awarded to a beneficiary.
+         **/
+        Awarded: GenericPalletEvent<'ChildBounties', 'Awarded', {
+            index: number;
+            childIndex: number;
+            beneficiary: AccountId32;
+        }>;
+        /**
+         * A child-bounty is claimed by beneficiary.
+         **/
+        Claimed: GenericPalletEvent<'ChildBounties', 'Claimed', {
+            index: number;
+            childIndex: number;
+            payout: bigint;
+            beneficiary: AccountId32;
+        }>;
+        /**
+         * A child-bounty is cancelled.
+         **/
+        Canceled: GenericPalletEvent<'ChildBounties', 'Canceled', {
+            index: number;
+            childIndex: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `ElectionProviderMultiPhase`'s events
+     **/
+    electionProviderMultiPhase: {
+        /**
+         * 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 submited 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: GenericPalletEvent<'ElectionProviderMultiPhase', 'SolutionStored', {
+            compute: PalletElectionProviderMultiPhaseElectionCompute;
+            origin?: AccountId32 | undefined;
+            prevEjected: boolean;
+        }>;
+        /**
+         * The election has been finalized, with the given computation and score.
+         **/
+        ElectionFinalized: GenericPalletEvent<'ElectionProviderMultiPhase', 'ElectionFinalized', {
+            compute: PalletElectionProviderMultiPhaseElectionCompute;
+            score: SpNposElectionsElectionScore;
+        }>;
+        /**
+         * An election failed.
+         *
+         * Not much can be said about which computes failed in the process.
+         **/
+        ElectionFailed: GenericPalletEvent<'ElectionProviderMultiPhase', 'ElectionFailed', null>;
+        /**
+         * An account has been rewarded for their signed submission being finalized.
+         **/
+        Rewarded: GenericPalletEvent<'ElectionProviderMultiPhase', 'Rewarded', {
+            account: AccountId32;
+            value: bigint;
+        }>;
+        /**
+         * An account has been slashed for submitting an invalid signed submission.
+         **/
+        Slashed: GenericPalletEvent<'ElectionProviderMultiPhase', 'Slashed', {
+            account: AccountId32;
+            value: bigint;
+        }>;
+        /**
+         * There was a phase transition in a given round.
+         **/
+        PhaseTransitioned: GenericPalletEvent<'ElectionProviderMultiPhase', 'PhaseTransitioned', {
+            from: PalletElectionProviderMultiPhasePhase;
+            to: PalletElectionProviderMultiPhasePhase;
+            round: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Nis`'s events
+     **/
+    nis: {
+        /**
+         * A bid was successfully placed.
+         **/
+        BidPlaced: GenericPalletEvent<'Nis', 'BidPlaced', {
+            who: AccountId32;
+            amount: bigint;
+            duration: number;
+        }>;
+        /**
+         * A bid was successfully removed (before being accepted).
+         **/
+        BidRetracted: GenericPalletEvent<'Nis', 'BidRetracted', {
+            who: AccountId32;
+            amount: bigint;
+            duration: number;
+        }>;
+        /**
+         * A bid was dropped from a queue because of another, more substantial, bid was present.
+         **/
+        BidDropped: GenericPalletEvent<'Nis', 'BidDropped', {
+            who: AccountId32;
+            amount: bigint;
+            duration: number;
+        }>;
+        /**
+         * A bid was accepted. The balance may not be released until expiry.
+         **/
+        Issued: GenericPalletEvent<'Nis', 'Issued', {
+            /**
+             * The identity of the receipt.
+             **/
+            index: number;
+            /**
+             * The block number at which the receipt may be thawed.
+             **/
+            expiry: number;
+            /**
+             * The owner of the receipt.
+             **/
+            who: AccountId32;
+            /**
+             * The proportion of the effective total issuance which the receipt represents.
+             **/
+            proportion: Perquintill;
+            /**
+             * The amount of funds which were debited from the owner.
+             **/
+            amount: bigint;
+        }>;
+        /**
+         * An receipt has been (at least partially) thawed.
+         **/
+        Thawed: GenericPalletEvent<'Nis', 'Thawed', {
+            /**
+             * The identity of the receipt.
+             **/
+            index: number;
+            /**
+             * The owner.
+             **/
+            who: AccountId32;
+            /**
+             * The proportion of the effective total issuance by which the owner was debited.
+             **/
+            proportion: Perquintill;
+            /**
+             * The amount by which the owner was credited.
+             **/
+            amount: bigint;
+            /**
+             * If `true` then the receipt is done.
+             **/
+            dropped: boolean;
+        }>;
+        /**
+         * An automatic funding of the deficit was made.
+         **/
+        Funded: GenericPalletEvent<'Nis', 'Funded', {
+            deficit: bigint;
+        }>;
+        /**
+         * A receipt was transfered.
+         **/
+        Transferred: GenericPalletEvent<'Nis', 'Transferred', {
+            from: AccountId32;
+            to: AccountId32;
+            index: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `NisCounterpartBalances`'s events
+     **/
+    nisCounterpartBalances: {
+        /**
+         * An account was created with some free balance.
+         **/
+        Endowed: GenericPalletEvent<'NisCounterpartBalances', 'Endowed', {
+            account: AccountId32;
+            freeBalance: bigint;
+        }>;
+        /**
+         * An account was removed whose balance was non-zero but below ExistentialDeposit,
+         * resulting in an outright loss.
+         **/
+        DustLost: GenericPalletEvent<'NisCounterpartBalances', 'DustLost', {
+            account: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Transfer succeeded.
+         **/
+        Transfer: GenericPalletEvent<'NisCounterpartBalances', 'Transfer', {
+            from: AccountId32;
+            to: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * A balance was set by root.
+         **/
+        BalanceSet: GenericPalletEvent<'NisCounterpartBalances', 'BalanceSet', {
+            who: AccountId32;
+            free: bigint;
+        }>;
+        /**
+         * Some balance was reserved (moved from free to reserved).
+         **/
+        Reserved: GenericPalletEvent<'NisCounterpartBalances', 'Reserved', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some balance was unreserved (moved from reserved to free).
+         **/
+        Unreserved: GenericPalletEvent<'NisCounterpartBalances', 'Unreserved', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some balance was moved from the reserve of the first account to the second account.
+         * Final argument indicates the destination balance type.
+         **/
+        ReserveRepatriated: GenericPalletEvent<'NisCounterpartBalances', 'ReserveRepatriated', {
+            from: AccountId32;
+            to: AccountId32;
+            amount: bigint;
+            destinationStatus: FrameSupportTokensMiscBalanceStatus;
+        }>;
+        /**
+         * Some amount was deposited (e.g. for transaction fees).
+         **/
+        Deposit: GenericPalletEvent<'NisCounterpartBalances', 'Deposit', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some amount was withdrawn from the account (e.g. for transaction fees).
+         **/
+        Withdraw: GenericPalletEvent<'NisCounterpartBalances', 'Withdraw', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some amount was removed from the account (e.g. for misbehavior).
+         **/
+        Slashed: GenericPalletEvent<'NisCounterpartBalances', 'Slashed', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some amount was minted into an account.
+         **/
+        Minted: GenericPalletEvent<'NisCounterpartBalances', 'Minted', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some amount was burned from an account.
+         **/
+        Burned: GenericPalletEvent<'NisCounterpartBalances', 'Burned', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some amount was suspended from an account (it can be restored later).
+         **/
+        Suspended: GenericPalletEvent<'NisCounterpartBalances', 'Suspended', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some amount was restored into an account.
+         **/
+        Restored: GenericPalletEvent<'NisCounterpartBalances', 'Restored', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An account was upgraded.
+         **/
+        Upgraded: GenericPalletEvent<'NisCounterpartBalances', 'Upgraded', {
+            who: AccountId32;
+        }>;
+        /**
+         * Total issuance was increased by `amount`, creating a credit to be balanced.
+         **/
+        Issued: GenericPalletEvent<'NisCounterpartBalances', 'Issued', {
+            amount: bigint;
+        }>;
+        /**
+         * Total issuance was decreased by `amount`, creating a debt to be balanced.
+         **/
+        Rescinded: GenericPalletEvent<'NisCounterpartBalances', 'Rescinded', {
+            amount: bigint;
+        }>;
+        /**
+         * Some balance was locked.
+         **/
+        Locked: GenericPalletEvent<'NisCounterpartBalances', 'Locked', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some balance was unlocked.
+         **/
+        Unlocked: GenericPalletEvent<'NisCounterpartBalances', 'Unlocked', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some balance was frozen.
+         **/
+        Frozen: GenericPalletEvent<'NisCounterpartBalances', 'Frozen', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some balance was thawed.
+         **/
+        Thawed: GenericPalletEvent<'NisCounterpartBalances', 'Thawed', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `VoterList`'s events
+     **/
+    voterList: {
+        /**
+         * Moved an account from one bag to another.
+         **/
+        Rebagged: GenericPalletEvent<'VoterList', 'Rebagged', {
+            who: AccountId32;
+            from: bigint;
+            to: bigint;
+        }>;
+        /**
+         * Updated the score of some account to the given amount.
+         **/
+        ScoreUpdated: GenericPalletEvent<'VoterList', 'ScoreUpdated', {
+            who: AccountId32;
+            newScore: bigint;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `NominationPools`'s events
+     **/
+    nominationPools: {
+        /**
+         * A pool has been created.
+         **/
+        Created: GenericPalletEvent<'NominationPools', 'Created', {
+            depositor: AccountId32;
+            poolId: number;
+        }>;
+        /**
+         * A member has became bonded in a pool.
+         **/
+        Bonded: GenericPalletEvent<'NominationPools', 'Bonded', {
+            member: AccountId32;
+            poolId: number;
+            bonded: bigint;
+            joined: boolean;
+        }>;
+        /**
+         * A payout has been made to a member.
+         **/
+        PaidOut: GenericPalletEvent<'NominationPools', 'PaidOut', {
+            member: AccountId32;
+            poolId: number;
+            payout: bigint;
+        }>;
+        /**
+         * 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: GenericPalletEvent<'NominationPools', 'Unbonded', {
+            member: AccountId32;
+            poolId: number;
+            balance: bigint;
+            points: bigint;
+            era: number;
+        }>;
+        /**
+         * 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: GenericPalletEvent<'NominationPools', 'Withdrawn', {
+            member: AccountId32;
+            poolId: number;
+            balance: bigint;
+            points: bigint;
+        }>;
+        /**
+         * A pool has been destroyed.
+         **/
+        Destroyed: GenericPalletEvent<'NominationPools', 'Destroyed', {
+            poolId: number;
+        }>;
+        /**
+         * The state of a pool has changed
+         **/
+        StateChanged: GenericPalletEvent<'NominationPools', 'StateChanged', {
+            poolId: number;
+            newState: PalletNominationPoolsPoolState;
+        }>;
+        /**
+         * A member has been removed from a pool.
+         *
+         * The removal can be voluntary (withdrawn all unbonded funds) or involuntary (kicked).
+         **/
+        MemberRemoved: GenericPalletEvent<'NominationPools', 'MemberRemoved', {
+            poolId: number;
+            member: AccountId32;
+        }>;
+        /**
+         * The roles of a pool have been updated to the given new roles. Note that the depositor
+         * can never change.
+         **/
+        RolesUpdated: GenericPalletEvent<'NominationPools', 'RolesUpdated', {
+            root?: AccountId32 | undefined;
+            bouncer?: AccountId32 | undefined;
+            nominator?: AccountId32 | undefined;
+        }>;
+        /**
+         * The active balance of pool `pool_id` has been slashed to `balance`.
+         **/
+        PoolSlashed: GenericPalletEvent<'NominationPools', 'PoolSlashed', {
+            poolId: number;
+            balance: bigint;
+        }>;
+        /**
+         * The unbond pool at `era` of pool `pool_id` has been slashed to `balance`.
+         **/
+        UnbondingPoolSlashed: GenericPalletEvent<'NominationPools', 'UnbondingPoolSlashed', {
+            poolId: number;
+            era: number;
+            balance: bigint;
+        }>;
+        /**
+         * A pool's commission setting has been changed.
+         **/
+        PoolCommissionUpdated: GenericPalletEvent<'NominationPools', 'PoolCommissionUpdated', {
+            poolId: number;
+            current?: [Perbill, AccountId32] | undefined;
+        }>;
+        /**
+         * A pool's maximum commission setting has been changed.
+         **/
+        PoolMaxCommissionUpdated: GenericPalletEvent<'NominationPools', 'PoolMaxCommissionUpdated', {
+            poolId: number;
+            maxCommission: Perbill;
+        }>;
+        /**
+         * A pool's commission `change_rate` has been changed.
+         **/
+        PoolCommissionChangeRateUpdated: GenericPalletEvent<'NominationPools', 'PoolCommissionChangeRateUpdated', {
+            poolId: number;
+            changeRate: PalletNominationPoolsCommissionChangeRate;
+        }>;
+        /**
+         * Pool commission has been claimed.
+         **/
+        PoolCommissionClaimed: GenericPalletEvent<'NominationPools', 'PoolCommissionClaimed', {
+            poolId: number;
+            commission: bigint;
+        }>;
+        /**
+         * Topped up deficit in frozen ED of the reward pool.
+         **/
+        MinBalanceDeficitAdjusted: GenericPalletEvent<'NominationPools', 'MinBalanceDeficitAdjusted', {
+            poolId: number;
+            amount: bigint;
+        }>;
+        /**
+         * Claimed excess frozen ED of af the reward pool.
+         **/
+        MinBalanceExcessAdjusted: GenericPalletEvent<'NominationPools', 'MinBalanceExcessAdjusted', {
+            poolId: number;
+            amount: bigint;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `FastUnstake`'s events
+     **/
+    fastUnstake: {
+        /**
+         * A staker was unstaked.
+         **/
+        Unstaked: GenericPalletEvent<'FastUnstake', 'Unstaked', {
+            stash: AccountId32;
+            result: Result<[], DispatchError>;
+        }>;
+        /**
+         * A staker was slashed for requesting fast-unstake whilst being exposed.
+         **/
+        Slashed: GenericPalletEvent<'FastUnstake', 'Slashed', {
+            stash: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * A batch was partially checked for the given eras, but the process did not finish.
+         **/
+        BatchChecked: GenericPalletEvent<'FastUnstake', 'BatchChecked', {
+            eras: Array<number>;
+        }>;
+        /**
+         * 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: GenericPalletEvent<'FastUnstake', 'BatchFinished', {
+            size: number;
+        }>;
+        /**
+         * An internal error happened. Operations will be paused now.
+         **/
+        InternalError: GenericPalletEvent<'FastUnstake', 'InternalError', null>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `ParaInclusion`'s events
+     **/
+    paraInclusion: {
+        /**
+         * A candidate was backed. `[candidate, head_data]`
+         **/
+        CandidateBacked: GenericPalletEvent<'ParaInclusion', 'CandidateBacked', [
+            PolkadotPrimitivesV6CandidateReceipt,
+            PolkadotParachainPrimitivesPrimitivesHeadData,
+            PolkadotPrimitivesV6CoreIndex,
+            PolkadotPrimitivesV6GroupIndex
+        ]>;
+        /**
+         * A candidate was included. `[candidate, head_data]`
+         **/
+        CandidateIncluded: GenericPalletEvent<'ParaInclusion', 'CandidateIncluded', [
+            PolkadotPrimitivesV6CandidateReceipt,
+            PolkadotParachainPrimitivesPrimitivesHeadData,
+            PolkadotPrimitivesV6CoreIndex,
+            PolkadotPrimitivesV6GroupIndex
+        ]>;
+        /**
+         * A candidate timed out. `[candidate, head_data]`
+         **/
+        CandidateTimedOut: GenericPalletEvent<'ParaInclusion', 'CandidateTimedOut', [
+            PolkadotPrimitivesV6CandidateReceipt,
+            PolkadotParachainPrimitivesPrimitivesHeadData,
+            PolkadotPrimitivesV6CoreIndex
+        ]>;
+        /**
+         * Some upward messages have been received and will be processed.
+         **/
+        UpwardMessagesReceived: GenericPalletEvent<'ParaInclusion', 'UpwardMessagesReceived', {
+            from: PolkadotParachainPrimitivesPrimitivesId;
+            count: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Paras`'s events
+     **/
+    paras: {
+        /**
+         * Current code has been updated for a Para. `para_id`
+         **/
+        CurrentCodeUpdated: GenericPalletEvent<'Paras', 'CurrentCodeUpdated', PolkadotParachainPrimitivesPrimitivesId>;
+        /**
+         * Current head has been updated for a Para. `para_id`
+         **/
+        CurrentHeadUpdated: GenericPalletEvent<'Paras', 'CurrentHeadUpdated', PolkadotParachainPrimitivesPrimitivesId>;
+        /**
+         * A code upgrade has been scheduled for a Para. `para_id`
+         **/
+        CodeUpgradeScheduled: GenericPalletEvent<'Paras', 'CodeUpgradeScheduled', PolkadotParachainPrimitivesPrimitivesId>;
+        /**
+         * A new head has been noted for a Para. `para_id`
+         **/
+        NewHeadNoted: GenericPalletEvent<'Paras', 'NewHeadNoted', PolkadotParachainPrimitivesPrimitivesId>;
+        /**
+         * A para has been queued to execute pending actions. `para_id`
+         **/
+        ActionQueued: GenericPalletEvent<'Paras', 'ActionQueued', [PolkadotParachainPrimitivesPrimitivesId, number]>;
+        /**
+         * The given para either initiated or subscribed to a PVF check for the given validation
+         * code. `code_hash` `para_id`
+         **/
+        PvfCheckStarted: GenericPalletEvent<'Paras', 'PvfCheckStarted', [
+            PolkadotParachainPrimitivesPrimitivesValidationCodeHash,
+            PolkadotParachainPrimitivesPrimitivesId
+        ]>;
+        /**
+         * The given validation code was accepted by the PVF pre-checking vote.
+         * `code_hash` `para_id`
+         **/
+        PvfCheckAccepted: GenericPalletEvent<'Paras', 'PvfCheckAccepted', [
+            PolkadotParachainPrimitivesPrimitivesValidationCodeHash,
+            PolkadotParachainPrimitivesPrimitivesId
+        ]>;
+        /**
+         * The given validation code was rejected by the PVF pre-checking vote.
+         * `code_hash` `para_id`
+         **/
+        PvfCheckRejected: GenericPalletEvent<'Paras', 'PvfCheckRejected', [
+            PolkadotParachainPrimitivesPrimitivesValidationCodeHash,
+            PolkadotParachainPrimitivesPrimitivesId
+        ]>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Hrmp`'s events
+     **/
+    hrmp: {
+        /**
+         * Open HRMP channel requested.
+         **/
+        OpenChannelRequested: GenericPalletEvent<'Hrmp', 'OpenChannelRequested', {
+            sender: PolkadotParachainPrimitivesPrimitivesId;
+            recipient: PolkadotParachainPrimitivesPrimitivesId;
+            proposedMaxCapacity: number;
+            proposedMaxMessageSize: number;
+        }>;
+        /**
+         * An HRMP channel request sent by the receiver was canceled by either party.
+         **/
+        OpenChannelCanceled: GenericPalletEvent<'Hrmp', 'OpenChannelCanceled', {
+            byParachain: PolkadotParachainPrimitivesPrimitivesId;
+            channelId: PolkadotParachainPrimitivesPrimitivesHrmpChannelId;
+        }>;
+        /**
+         * Open HRMP channel accepted.
+         **/
+        OpenChannelAccepted: GenericPalletEvent<'Hrmp', 'OpenChannelAccepted', {
+            sender: PolkadotParachainPrimitivesPrimitivesId;
+            recipient: PolkadotParachainPrimitivesPrimitivesId;
+        }>;
+        /**
+         * HRMP channel closed.
+         **/
+        ChannelClosed: GenericPalletEvent<'Hrmp', 'ChannelClosed', {
+            byParachain: PolkadotParachainPrimitivesPrimitivesId;
+            channelId: PolkadotParachainPrimitivesPrimitivesHrmpChannelId;
+        }>;
+        /**
+         * An HRMP channel was opened via Root origin.
+         **/
+        HrmpChannelForceOpened: GenericPalletEvent<'Hrmp', 'HrmpChannelForceOpened', {
+            sender: PolkadotParachainPrimitivesPrimitivesId;
+            recipient: PolkadotParachainPrimitivesPrimitivesId;
+            proposedMaxCapacity: number;
+            proposedMaxMessageSize: number;
+        }>;
+        /**
+         * An HRMP channel was opened between two system chains.
+         **/
+        HrmpSystemChannelOpened: GenericPalletEvent<'Hrmp', 'HrmpSystemChannelOpened', {
+            sender: PolkadotParachainPrimitivesPrimitivesId;
+            recipient: PolkadotParachainPrimitivesPrimitivesId;
+            proposedMaxCapacity: number;
+            proposedMaxMessageSize: number;
+        }>;
+        /**
+         * An HRMP channel's deposits were updated.
+         **/
+        OpenChannelDepositsUpdated: GenericPalletEvent<'Hrmp', 'OpenChannelDepositsUpdated', {
+            sender: PolkadotParachainPrimitivesPrimitivesId;
+            recipient: PolkadotParachainPrimitivesPrimitivesId;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `ParasDisputes`'s events
+     **/
+    parasDisputes: {
+        /**
+         * A dispute has been initiated. \[candidate hash, dispute location\]
+         **/
+        DisputeInitiated: GenericPalletEvent<'ParasDisputes', 'DisputeInitiated', [
+            PolkadotCorePrimitivesCandidateHash,
+            PolkadotRuntimeParachainsDisputesDisputeLocation
+        ]>;
+        /**
+         * A dispute has concluded for or against a candidate.
+         * `\[para id, candidate hash, dispute result\]`
+         **/
+        DisputeConcluded: GenericPalletEvent<'ParasDisputes', 'DisputeConcluded', [
+            PolkadotCorePrimitivesCandidateHash,
+            PolkadotRuntimeParachainsDisputesDisputeResult
+        ]>;
+        /**
+         * 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: GenericPalletEvent<'ParasDisputes', 'Revert', number>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Registrar`'s events
+     **/
+    registrar: {
+        Registered: GenericPalletEvent<'Registrar', 'Registered', {
+            paraId: PolkadotParachainPrimitivesPrimitivesId;
+            manager: AccountId32;
+        }>;
+        Deregistered: GenericPalletEvent<'Registrar', 'Deregistered', {
+            paraId: PolkadotParachainPrimitivesPrimitivesId;
+        }>;
+        Reserved: GenericPalletEvent<'Registrar', 'Reserved', {
+            paraId: PolkadotParachainPrimitivesPrimitivesId;
+            who: AccountId32;
+        }>;
+        Swapped: GenericPalletEvent<'Registrar', 'Swapped', {
+            paraId: PolkadotParachainPrimitivesPrimitivesId;
+            otherId: PolkadotParachainPrimitivesPrimitivesId;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Slots`'s events
+     **/
+    slots: {
+        /**
+         * A new `[lease_period]` is beginning.
+         **/
+        NewLeasePeriod: GenericPalletEvent<'Slots', 'NewLeasePeriod', {
+            leasePeriod: number;
+        }>;
+        /**
+         * 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: GenericPalletEvent<'Slots', 'Leased', {
+            paraId: PolkadotParachainPrimitivesPrimitivesId;
+            leaser: AccountId32;
+            periodBegin: number;
+            periodCount: number;
+            extraReserved: bigint;
+            totalAmount: bigint;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Auctions`'s events
+     **/
+    auctions: {
+        /**
+         * 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: GenericPalletEvent<'Auctions', 'AuctionStarted', {
+            auctionIndex: number;
+            leasePeriod: number;
+            ending: number;
+        }>;
+        /**
+         * An auction ended. All funds become unreserved.
+         **/
+        AuctionClosed: GenericPalletEvent<'Auctions', 'AuctionClosed', {
+            auctionIndex: number;
+        }>;
+        /**
+         * Funds were reserved for a winning bid. First balance is the extra amount reserved.
+         * Second is the total.
+         **/
+        Reserved: GenericPalletEvent<'Auctions', 'Reserved', {
+            bidder: AccountId32;
+            extraReserved: bigint;
+            totalAmount: bigint;
+        }>;
+        /**
+         * Funds were unreserved since bidder is no longer active. `[bidder, amount]`
+         **/
+        Unreserved: GenericPalletEvent<'Auctions', 'Unreserved', {
+            bidder: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * 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: GenericPalletEvent<'Auctions', 'ReserveConfiscated', {
+            paraId: PolkadotParachainPrimitivesPrimitivesId;
+            leaser: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * A new bid has been accepted as the current winner.
+         **/
+        BidAccepted: GenericPalletEvent<'Auctions', 'BidAccepted', {
+            bidder: AccountId32;
+            paraId: PolkadotParachainPrimitivesPrimitivesId;
+            amount: bigint;
+            firstSlot: number;
+            lastSlot: number;
+        }>;
+        /**
+         * The winning offset was chosen for an auction. This will map into the `Winning` storage
+         * map.
+         **/
+        WinningOffset: GenericPalletEvent<'Auctions', 'WinningOffset', {
+            auctionIndex: number;
+            blockNumber: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Crowdloan`'s events
+     **/
+    crowdloan: {
+        /**
+         * Create a new crowdloaning campaign.
+         **/
+        Created: GenericPalletEvent<'Crowdloan', 'Created', {
+            paraId: PolkadotParachainPrimitivesPrimitivesId;
+        }>;
+        /**
+         * Contributed to a crowd sale.
+         **/
+        Contributed: GenericPalletEvent<'Crowdloan', 'Contributed', {
+            who: AccountId32;
+            fundIndex: PolkadotParachainPrimitivesPrimitivesId;
+            amount: bigint;
+        }>;
+        /**
+         * Withdrew full balance of a contributor.
+         **/
+        Withdrew: GenericPalletEvent<'Crowdloan', 'Withdrew', {
+            who: AccountId32;
+            fundIndex: PolkadotParachainPrimitivesPrimitivesId;
+            amount: bigint;
+        }>;
+        /**
+         * 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: GenericPalletEvent<'Crowdloan', 'PartiallyRefunded', {
+            paraId: PolkadotParachainPrimitivesPrimitivesId;
+        }>;
+        /**
+         * All loans in a fund have been refunded.
+         **/
+        AllRefunded: GenericPalletEvent<'Crowdloan', 'AllRefunded', {
+            paraId: PolkadotParachainPrimitivesPrimitivesId;
+        }>;
+        /**
+         * Fund is dissolved.
+         **/
+        Dissolved: GenericPalletEvent<'Crowdloan', 'Dissolved', {
+            paraId: PolkadotParachainPrimitivesPrimitivesId;
+        }>;
+        /**
+         * The result of trying to submit a new bid to the Slots pallet.
+         **/
+        HandleBidResult: GenericPalletEvent<'Crowdloan', 'HandleBidResult', {
+            paraId: PolkadotParachainPrimitivesPrimitivesId;
+            result: Result<[], DispatchError>;
+        }>;
+        /**
+         * The configuration to a crowdloan has been edited.
+         **/
+        Edited: GenericPalletEvent<'Crowdloan', 'Edited', {
+            paraId: PolkadotParachainPrimitivesPrimitivesId;
+        }>;
+        /**
+         * A memo has been updated.
+         **/
+        MemoUpdated: GenericPalletEvent<'Crowdloan', 'MemoUpdated', {
+            who: AccountId32;
+            paraId: PolkadotParachainPrimitivesPrimitivesId;
+            memo: Bytes;
+        }>;
+        /**
+         * A parachain has been moved to `NewRaise`
+         **/
+        AddedToNewRaise: GenericPalletEvent<'Crowdloan', 'AddedToNewRaise', {
+            paraId: PolkadotParachainPrimitivesPrimitivesId;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `StateTrieMigration`'s events
+     **/
+    stateTrieMigration: {
+        /**
+         * Given number of `(top, child)` keys were migrated respectively, with the given
+         * `compute`.
+         **/
+        Migrated: GenericPalletEvent<'StateTrieMigration', 'Migrated', {
+            top: number;
+            child: number;
+            compute: PalletStateTrieMigrationMigrationCompute;
+        }>;
+        /**
+         * Some account got slashed by the given amount.
+         **/
+        Slashed: GenericPalletEvent<'StateTrieMigration', 'Slashed', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * The auto migration task finished.
+         **/
+        AutoMigrationFinished: GenericPalletEvent<'StateTrieMigration', 'AutoMigrationFinished', null>;
+        /**
+         * Migration got halted due to an error or miss-configuration.
+         **/
+        Halted: GenericPalletEvent<'StateTrieMigration', 'Halted', {
+            error: PalletStateTrieMigrationError;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `XcmPallet`'s events
+     **/
+    xcmPallet: {
+        /**
+         * Execution of an XCM message was attempted.
+         **/
+        Attempted: GenericPalletEvent<'XcmPallet', 'Attempted', {
+            outcome: XcmV3TraitsOutcome;
+        }>;
+        /**
+         * A XCM message was sent.
+         **/
+        Sent: GenericPalletEvent<'XcmPallet', 'Sent', {
+            origin: StagingXcmV3MultilocationMultiLocation;
+            destination: StagingXcmV3MultilocationMultiLocation;
+            message: XcmV3Xcm;
+            messageId: FixedBytes<32>;
+        }>;
+        /**
+         * 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: GenericPalletEvent<'XcmPallet', 'UnexpectedResponse', {
+            origin: StagingXcmV3MultilocationMultiLocation;
+            queryId: bigint;
+        }>;
+        /**
+         * Query response has been received and is ready for taking with `take_response`. There is
+         * no registered notification call.
+         **/
+        ResponseReady: GenericPalletEvent<'XcmPallet', 'ResponseReady', {
+            queryId: bigint;
+            response: XcmV3Response;
+        }>;
+        /**
+         * Query response has been received and query is removed. The registered notification has
+         * been dispatched and executed successfully.
+         **/
+        Notified: GenericPalletEvent<'XcmPallet', 'Notified', {
+            queryId: bigint;
+            palletIndex: number;
+            callIndex: number;
+        }>;
+        /**
+         * 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: GenericPalletEvent<'XcmPallet', 'NotifyOverweight', {
+            queryId: bigint;
+            palletIndex: number;
+            callIndex: number;
+            actualWeight: SpWeightsWeightV2Weight;
+            maxBudgetedWeight: SpWeightsWeightV2Weight;
+        }>;
+        /**
+         * Query response has been received and query is removed. There was a general error with
+         * dispatching the notification call.
+         **/
+        NotifyDispatchError: GenericPalletEvent<'XcmPallet', 'NotifyDispatchError', {
+            queryId: bigint;
+            palletIndex: number;
+            callIndex: number;
+        }>;
+        /**
+         * 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: GenericPalletEvent<'XcmPallet', 'NotifyDecodeFailed', {
+            queryId: bigint;
+            palletIndex: number;
+            callIndex: number;
+        }>;
+        /**
+         * 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: GenericPalletEvent<'XcmPallet', 'InvalidResponder', {
+            origin: StagingXcmV3MultilocationMultiLocation;
+            queryId: bigint;
+            expectedLocation?: StagingXcmV3MultilocationMultiLocation | undefined;
+        }>;
+        /**
+         * 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: GenericPalletEvent<'XcmPallet', 'InvalidResponderVersion', {
+            origin: StagingXcmV3MultilocationMultiLocation;
+            queryId: bigint;
+        }>;
+        /**
+         * Received query response has been read and removed.
+         **/
+        ResponseTaken: GenericPalletEvent<'XcmPallet', 'ResponseTaken', {
+            queryId: bigint;
+        }>;
+        /**
+         * Some assets have been placed in an asset trap.
+         **/
+        AssetsTrapped: GenericPalletEvent<'XcmPallet', 'AssetsTrapped', {
+            hash: H256;
+            origin: StagingXcmV3MultilocationMultiLocation;
+            assets: XcmVersionedMultiAssets;
+        }>;
+        /**
+         * An XCM version change notification message has been attempted to be sent.
+         *
+         * The cost of sending it (borne by the chain) is included.
+         **/
+        VersionChangeNotified: GenericPalletEvent<'XcmPallet', 'VersionChangeNotified', {
+            destination: StagingXcmV3MultilocationMultiLocation;
+            result: number;
+            cost: XcmV3MultiassetMultiAssets;
+            messageId: FixedBytes<32>;
+        }>;
+        /**
+         * The supported version of a location has been changed. This might be through an
+         * automatic notification or a manual intervention.
+         **/
+        SupportedVersionChanged: GenericPalletEvent<'XcmPallet', 'SupportedVersionChanged', {
+            location: StagingXcmV3MultilocationMultiLocation;
+            version: number;
+        }>;
+        /**
+         * A given location which had a version change subscription was dropped owing to an error
+         * sending the notification to it.
+         **/
+        NotifyTargetSendFail: GenericPalletEvent<'XcmPallet', 'NotifyTargetSendFail', {
+            location: StagingXcmV3MultilocationMultiLocation;
+            queryId: bigint;
+            error: XcmV3TraitsError;
+        }>;
+        /**
+         * A given location which had a version change subscription was dropped owing to an error
+         * migrating the location to our new XCM format.
+         **/
+        NotifyTargetMigrationFail: GenericPalletEvent<'XcmPallet', 'NotifyTargetMigrationFail', {
+            location: XcmVersionedMultiLocation;
+            queryId: bigint;
+        }>;
+        /**
+         * 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: GenericPalletEvent<'XcmPallet', 'InvalidQuerierVersion', {
+            origin: StagingXcmV3MultilocationMultiLocation;
+            queryId: bigint;
+        }>;
+        /**
+         * 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: GenericPalletEvent<'XcmPallet', 'InvalidQuerier', {
+            origin: StagingXcmV3MultilocationMultiLocation;
+            queryId: bigint;
+            expectedQuerier: StagingXcmV3MultilocationMultiLocation;
+            maybeActualQuerier?: StagingXcmV3MultilocationMultiLocation | undefined;
+        }>;
+        /**
+         * 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: GenericPalletEvent<'XcmPallet', 'VersionNotifyStarted', {
+            destination: StagingXcmV3MultilocationMultiLocation;
+            cost: XcmV3MultiassetMultiAssets;
+            messageId: FixedBytes<32>;
+        }>;
+        /**
+         * We have requested that a remote chain send us XCM version change notifications.
+         **/
+        VersionNotifyRequested: GenericPalletEvent<'XcmPallet', 'VersionNotifyRequested', {
+            destination: StagingXcmV3MultilocationMultiLocation;
+            cost: XcmV3MultiassetMultiAssets;
+            messageId: FixedBytes<32>;
+        }>;
+        /**
+         * We have requested that a remote chain stops sending us XCM version change
+         * notifications.
+         **/
+        VersionNotifyUnrequested: GenericPalletEvent<'XcmPallet', 'VersionNotifyUnrequested', {
+            destination: StagingXcmV3MultilocationMultiLocation;
+            cost: XcmV3MultiassetMultiAssets;
+            messageId: FixedBytes<32>;
+        }>;
+        /**
+         * Fees were paid from a location for an operation (often for using `SendXcm`).
+         **/
+        FeesPaid: GenericPalletEvent<'XcmPallet', 'FeesPaid', {
+            paying: StagingXcmV3MultilocationMultiLocation;
+            fees: XcmV3MultiassetMultiAssets;
+        }>;
+        /**
+         * Some assets have been claimed from an asset trap
+         **/
+        AssetsClaimed: GenericPalletEvent<'XcmPallet', 'AssetsClaimed', {
+            hash: H256;
+            origin: StagingXcmV3MultilocationMultiLocation;
+            assets: XcmVersionedMultiAssets;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `MessageQueue`'s events
+     **/
+    messageQueue: {
+        /**
+         * Message discarded due to an error in the `MessageProcessor` (usually a format error).
+         **/
+        ProcessingFailed: GenericPalletEvent<'MessageQueue', 'ProcessingFailed', {
+            id: FixedBytes<32>;
+            origin: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin;
+            error: FrameSupportMessagesProcessMessageError;
+        }>;
+        /**
+         * Message is processed.
+         **/
+        Processed: GenericPalletEvent<'MessageQueue', 'Processed', {
+            id: FixedBytes<32>;
+            origin: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin;
+            weightUsed: SpWeightsWeightV2Weight;
+            success: boolean;
+        }>;
+        /**
+         * Message placed in overweight queue.
+         **/
+        OverweightEnqueued: GenericPalletEvent<'MessageQueue', 'OverweightEnqueued', {
+            id: FixedBytes<32>;
+            origin: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin;
+            pageIndex: number;
+            messageIndex: number;
+        }>;
+        /**
+         * This page was reaped.
+         **/
+        PageReaped: GenericPalletEvent<'MessageQueue', 'PageReaped', {
+            origin: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin;
+            index: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `AssetRate`'s events
+     **/
+    assetRate: {
+        AssetRateCreated: GenericPalletEvent<'AssetRate', 'AssetRateCreated', {
+            assetKind: PolkadotRuntimeCommonImplsVersionedLocatableAsset;
+            rate: FixedU128;
+        }>;
+        AssetRateRemoved: GenericPalletEvent<'AssetRate', 'AssetRateRemoved', {
+            assetKind: PolkadotRuntimeCommonImplsVersionedLocatableAsset;
+        }>;
+        AssetRateUpdated: GenericPalletEvent<'AssetRate', 'AssetRateUpdated', {
+            assetKind: PolkadotRuntimeCommonImplsVersionedLocatableAsset;
+            old: FixedU128;
+            new: FixedU128;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+}