@dedot/chaintypes 0.0.1-alpha.22

package/substrate/events.d.ts

@@ -0,0 +1,4777 @@
+import type { GenericChainEvents, GenericPalletEvent } from '@dedot/types';
+import type { DispatchInfo, DispatchError, AccountId32, H256, Result, Perbill, FixedU128, Bytes, FixedBytes, FixedU64, Perquintill, Permill } from '@dedot/codecs';
+import type { FrameSupportTokensMiscBalanceStatus, PalletElectionProviderMultiPhaseElectionCompute, SpNposElectionsElectionScore, PalletElectionProviderMultiPhasePhase, PalletStakingValidatorPrefs, PalletStakingForcing, PalletDemocracyVoteThreshold, PalletDemocracyVoteAccountVote, PalletDemocracyMetadataOwner, SpConsensusGrandpaAppPublic, PalletContractsOrigin, PalletImOnlineSr25519AppSr25519Public, PalletStakingExposure, PalletSocietyGroupParams, KitchensinkRuntimeProxyType, PalletMultisigTimepoint, PalletNftsAttributeNamespace, PalletNftsPriceWithDirection, PalletNftsPalletAttributes, PalletCoreFellowshipParamsType, PalletCoreFellowshipWish, PalletStateTrieMigrationMigrationCompute, PalletStateTrieMigrationError, FrameSupportPreimagesBounded, PalletConvictionVotingTally, FrameSupportDispatchPostDispatchInfo, SpRuntimeDispatchErrorWithPostInfo, PalletAllianceCid, PalletAllianceUnscrupulousItem, PalletNominationPoolsPoolState, PalletNominationPoolsCommissionChangeRate, PalletRankedCollectiveTally, PalletRankedCollectiveVoteRecord, PalletAssetConversionNativeOrAssetId, FrameSupportMessagesProcessMessageError, SpWeightsWeightV2Weight, PalletSafeModeExitReason, SpStatementStoreStatement, PalletBrokerRegionId, PalletBrokerScheduleItem, PalletBrokerCoretimeInterfaceCoreAssignment } 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 `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 `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 `AssetTxPayment`'s events
+     **/
+    assetTxPayment: {
+        /**
+         * A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee,
+         * has been paid by `who` in an asset `asset_id`.
+         **/
+        AssetTxFeePaid: GenericPalletEvent<'AssetTxPayment', 'AssetTxFeePaid', {
+            who: AccountId32;
+            actualFee: bigint;
+            tip: bigint;
+            assetId?: number | undefined;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `AssetConversionTxPayment`'s events
+     **/
+    assetConversionTxPayment: {
+        /**
+         * A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee,
+         * has been paid by `who` in an asset `asset_id`.
+         **/
+        AssetTxFeePaid: GenericPalletEvent<'AssetConversionTxPayment', 'AssetTxFeePaid', {
+            who: AccountId32;
+            actualFee: bigint;
+            tip: bigint;
+            assetId: number;
+        }>;
+        /**
+         * A swap of the refund in native currency back to asset failed.
+         **/
+        AssetRefundFailed: GenericPalletEvent<'AssetConversionTxPayment', 'AssetRefundFailed', {
+            nativeAmountKept: bigint;
+        }>;
+        /**
+         * 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 `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.
+         **/
+        Rewarded: GenericPalletEvent<'Staking', 'Rewarded', {
+            stash: AccountId32;
+            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 `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 `Democracy`'s events
+     **/
+    democracy: {
+        /**
+         * A motion has been proposed by a public account.
+         **/
+        Proposed: GenericPalletEvent<'Democracy', 'Proposed', {
+            proposalIndex: number;
+            deposit: bigint;
+        }>;
+        /**
+         * A public proposal has been tabled for referendum vote.
+         **/
+        Tabled: GenericPalletEvent<'Democracy', 'Tabled', {
+            proposalIndex: number;
+            deposit: bigint;
+        }>;
+        /**
+         * An external proposal has been tabled.
+         **/
+        ExternalTabled: GenericPalletEvent<'Democracy', 'ExternalTabled', null>;
+        /**
+         * A referendum has begun.
+         **/
+        Started: GenericPalletEvent<'Democracy', 'Started', {
+            refIndex: number;
+            threshold: PalletDemocracyVoteThreshold;
+        }>;
+        /**
+         * A proposal has been approved by referendum.
+         **/
+        Passed: GenericPalletEvent<'Democracy', 'Passed', {
+            refIndex: number;
+        }>;
+        /**
+         * A proposal has been rejected by referendum.
+         **/
+        NotPassed: GenericPalletEvent<'Democracy', 'NotPassed', {
+            refIndex: number;
+        }>;
+        /**
+         * A referendum has been cancelled.
+         **/
+        Cancelled: GenericPalletEvent<'Democracy', 'Cancelled', {
+            refIndex: number;
+        }>;
+        /**
+         * An account has delegated their vote to another account.
+         **/
+        Delegated: GenericPalletEvent<'Democracy', 'Delegated', {
+            who: AccountId32;
+            target: AccountId32;
+        }>;
+        /**
+         * An account has cancelled a previous delegation operation.
+         **/
+        Undelegated: GenericPalletEvent<'Democracy', 'Undelegated', {
+            account: AccountId32;
+        }>;
+        /**
+         * An external proposal has been vetoed.
+         **/
+        Vetoed: GenericPalletEvent<'Democracy', 'Vetoed', {
+            who: AccountId32;
+            proposalHash: H256;
+            until: number;
+        }>;
+        /**
+         * A proposal_hash has been blacklisted permanently.
+         **/
+        Blacklisted: GenericPalletEvent<'Democracy', 'Blacklisted', {
+            proposalHash: H256;
+        }>;
+        /**
+         * An account has voted in a referendum
+         **/
+        Voted: GenericPalletEvent<'Democracy', 'Voted', {
+            voter: AccountId32;
+            refIndex: number;
+            vote: PalletDemocracyVoteAccountVote;
+        }>;
+        /**
+         * An account has secconded a proposal
+         **/
+        Seconded: GenericPalletEvent<'Democracy', 'Seconded', {
+            seconder: AccountId32;
+            propIndex: number;
+        }>;
+        /**
+         * A proposal got canceled.
+         **/
+        ProposalCanceled: GenericPalletEvent<'Democracy', 'ProposalCanceled', {
+            propIndex: number;
+        }>;
+        /**
+         * Metadata for a proposal or a referendum has been set.
+         **/
+        MetadataSet: GenericPalletEvent<'Democracy', 'MetadataSet', {
+            /**
+             * Metadata owner.
+             **/
+            owner: PalletDemocracyMetadataOwner;
+            /**
+             * Preimage hash.
+             **/
+            hash: H256;
+        }>;
+        /**
+         * Metadata for a proposal or a referendum has been cleared.
+         **/
+        MetadataCleared: GenericPalletEvent<'Democracy', 'MetadataCleared', {
+            /**
+             * Metadata owner.
+             **/
+            owner: PalletDemocracyMetadataOwner;
+            /**
+             * Preimage hash.
+             **/
+            hash: H256;
+        }>;
+        /**
+         * Metadata has been transferred to new owner.
+         **/
+        MetadataTransferred: GenericPalletEvent<'Democracy', 'MetadataTransferred', {
+            /**
+             * Previous metadata owner.
+             **/
+            prevOwner: PalletDemocracyMetadataOwner;
+            /**
+             * New metadata owner.
+             **/
+            owner: PalletDemocracyMetadataOwner;
+            /**
+             * Preimage hash.
+             **/
+            hash: H256;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Council`'s events
+     **/
+    council: {
+        /**
+         * A motion (given hash) has been proposed (by given account) with a threshold (given
+         * `MemberCount`).
+         **/
+        Proposed: GenericPalletEvent<'Council', 'Proposed', {
+            account: AccountId32;
+            proposalIndex: number;
+            proposalHash: H256;
+            threshold: number;
+        }>;
+        /**
+         * A motion (given hash) has been voted on by given account, leaving
+         * a tally (yes votes and no votes given respectively as `MemberCount`).
+         **/
+        Voted: GenericPalletEvent<'Council', 'Voted', {
+            account: AccountId32;
+            proposalHash: H256;
+            voted: boolean;
+            yes: number;
+            no: number;
+        }>;
+        /**
+         * A motion was approved by the required threshold.
+         **/
+        Approved: GenericPalletEvent<'Council', 'Approved', {
+            proposalHash: H256;
+        }>;
+        /**
+         * A motion was not approved by the required threshold.
+         **/
+        Disapproved: GenericPalletEvent<'Council', 'Disapproved', {
+            proposalHash: H256;
+        }>;
+        /**
+         * A motion was executed; result will be `Ok` if it returned without error.
+         **/
+        Executed: GenericPalletEvent<'Council', 'Executed', {
+            proposalHash: H256;
+            result: Result<[], DispatchError>;
+        }>;
+        /**
+         * A single member did some action; result will be `Ok` if it returned without error.
+         **/
+        MemberExecuted: GenericPalletEvent<'Council', 'MemberExecuted', {
+            proposalHash: H256;
+            result: Result<[], DispatchError>;
+        }>;
+        /**
+         * A proposal was closed because its threshold was reached or after its duration was up.
+         **/
+        Closed: GenericPalletEvent<'Council', 'Closed', {
+            proposalHash: H256;
+            yes: number;
+            no: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `TechnicalCommittee`'s events
+     **/
+    technicalCommittee: {
+        /**
+         * A motion (given hash) has been proposed (by given account) with a threshold (given
+         * `MemberCount`).
+         **/
+        Proposed: GenericPalletEvent<'TechnicalCommittee', 'Proposed', {
+            account: AccountId32;
+            proposalIndex: number;
+            proposalHash: H256;
+            threshold: number;
+        }>;
+        /**
+         * A motion (given hash) has been voted on by given account, leaving
+         * a tally (yes votes and no votes given respectively as `MemberCount`).
+         **/
+        Voted: GenericPalletEvent<'TechnicalCommittee', 'Voted', {
+            account: AccountId32;
+            proposalHash: H256;
+            voted: boolean;
+            yes: number;
+            no: number;
+        }>;
+        /**
+         * A motion was approved by the required threshold.
+         **/
+        Approved: GenericPalletEvent<'TechnicalCommittee', 'Approved', {
+            proposalHash: H256;
+        }>;
+        /**
+         * A motion was not approved by the required threshold.
+         **/
+        Disapproved: GenericPalletEvent<'TechnicalCommittee', 'Disapproved', {
+            proposalHash: H256;
+        }>;
+        /**
+         * A motion was executed; result will be `Ok` if it returned without error.
+         **/
+        Executed: GenericPalletEvent<'TechnicalCommittee', 'Executed', {
+            proposalHash: H256;
+            result: Result<[], DispatchError>;
+        }>;
+        /**
+         * A single member did some action; result will be `Ok` if it returned without error.
+         **/
+        MemberExecuted: GenericPalletEvent<'TechnicalCommittee', 'MemberExecuted', {
+            proposalHash: H256;
+            result: Result<[], DispatchError>;
+        }>;
+        /**
+         * A proposal was closed because its threshold was reached or after its duration was up.
+         **/
+        Closed: GenericPalletEvent<'TechnicalCommittee', 'Closed', {
+            proposalHash: H256;
+            yes: number;
+            no: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Elections`'s events
+     **/
+    elections: {
+        /**
+         * A new term with new_members. This indicates that enough candidates existed to run
+         * the election, not that enough have has been elected. The inner value must be examined
+         * for this purpose. A `NewTerm(\[\])` indicates that some candidates got their bond
+         * slashed and none were elected, whilst `EmptyTerm` means that no candidates existed to
+         * begin with.
+         **/
+        NewTerm: GenericPalletEvent<'Elections', 'NewTerm', {
+            newMembers: Array<[AccountId32, bigint]>;
+        }>;
+        /**
+         * No (or not enough) candidates existed for this round. This is different from
+         * `NewTerm(\[\])`. See the description of `NewTerm`.
+         **/
+        EmptyTerm: GenericPalletEvent<'Elections', 'EmptyTerm', null>;
+        /**
+         * Internal error happened while trying to perform election.
+         **/
+        ElectionError: GenericPalletEvent<'Elections', 'ElectionError', null>;
+        /**
+         * A member has been removed. This should always be followed by either `NewTerm` or
+         * `EmptyTerm`.
+         **/
+        MemberKicked: GenericPalletEvent<'Elections', 'MemberKicked', {
+            member: AccountId32;
+        }>;
+        /**
+         * Someone has renounced their candidacy.
+         **/
+        Renounced: GenericPalletEvent<'Elections', 'Renounced', {
+            candidate: AccountId32;
+        }>;
+        /**
+         * A candidate was slashed by amount due to failing to obtain a seat as member or
+         * runner-up.
+         *
+         * Note that old members and runners-up are also candidates.
+         **/
+        CandidateSlashed: GenericPalletEvent<'Elections', 'CandidateSlashed', {
+            candidate: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * A seat holder was slashed by amount by being forcefully removed from the set.
+         **/
+        SeatHolderSlashed: GenericPalletEvent<'Elections', 'SeatHolderSlashed', {
+            seatHolder: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `TechnicalMembership`'s events
+     **/
+    technicalMembership: {
+        /**
+         * The given member was added; see the transaction for who.
+         **/
+        MemberAdded: GenericPalletEvent<'TechnicalMembership', 'MemberAdded', undefined>;
+        /**
+         * The given member was removed; see the transaction for who.
+         **/
+        MemberRemoved: GenericPalletEvent<'TechnicalMembership', 'MemberRemoved', undefined>;
+        /**
+         * Two members were swapped; see the transaction for who.
+         **/
+        MembersSwapped: GenericPalletEvent<'TechnicalMembership', 'MembersSwapped', undefined>;
+        /**
+         * The membership was reset; see the transaction for who the new set is.
+         **/
+        MembersReset: GenericPalletEvent<'TechnicalMembership', 'MembersReset', undefined>;
+        /**
+         * One of the members' keys changed.
+         **/
+        KeyChanged: GenericPalletEvent<'TechnicalMembership', 'KeyChanged', undefined>;
+        /**
+         * Phantom member, never used.
+         **/
+        Dummy: GenericPalletEvent<'TechnicalMembership', 'Dummy', undefined>;
+        /**
+         * 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 `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;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `AssetRate`'s events
+     **/
+    assetRate: {
+        AssetRateCreated: GenericPalletEvent<'AssetRate', 'AssetRateCreated', {
+            assetKind: number;
+            rate: FixedU128;
+        }>;
+        AssetRateRemoved: GenericPalletEvent<'AssetRate', 'AssetRateRemoved', {
+            assetKind: number;
+        }>;
+        AssetRateUpdated: GenericPalletEvent<'AssetRate', 'AssetRateUpdated', {
+            assetKind: number;
+            old: FixedU128;
+            new: FixedU128;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Contracts`'s events
+     **/
+    contracts: {
+        /**
+         * Contract deployed by address at the specified address.
+         **/
+        Instantiated: GenericPalletEvent<'Contracts', 'Instantiated', {
+            deployer: AccountId32;
+            contract: AccountId32;
+        }>;
+        /**
+         * Contract has been removed.
+         *
+         * # Note
+         *
+         * The only way for a contract to be removed and emitting this event is by calling
+         * `seal_terminate`.
+         **/
+        Terminated: GenericPalletEvent<'Contracts', 'Terminated', {
+            /**
+             * The contract that was terminated.
+             **/
+            contract: AccountId32;
+            /**
+             * The account that received the contracts remaining balance
+             **/
+            beneficiary: AccountId32;
+        }>;
+        /**
+         * Code with the specified hash has been stored.
+         **/
+        CodeStored: GenericPalletEvent<'Contracts', 'CodeStored', {
+            codeHash: H256;
+            depositHeld: bigint;
+            uploader: AccountId32;
+        }>;
+        /**
+         * A custom event emitted by the contract.
+         **/
+        ContractEmitted: GenericPalletEvent<'Contracts', 'ContractEmitted', {
+            /**
+             * The contract that emitted the event.
+             **/
+            contract: AccountId32;
+            /**
+             * Data supplied by the contract. Metadata generated during contract compilation
+             * is needed to decode it.
+             **/
+            data: Bytes;
+        }>;
+        /**
+         * A code with the specified hash was removed.
+         **/
+        CodeRemoved: GenericPalletEvent<'Contracts', 'CodeRemoved', {
+            codeHash: H256;
+            depositReleased: bigint;
+            remover: AccountId32;
+        }>;
+        /**
+         * A contract's code was updated.
+         **/
+        ContractCodeUpdated: GenericPalletEvent<'Contracts', 'ContractCodeUpdated', {
+            /**
+             * The contract that has been updated.
+             **/
+            contract: AccountId32;
+            /**
+             * New code hash that was set for the contract.
+             **/
+            newCodeHash: H256;
+            /**
+             * Previous code hash of the contract.
+             **/
+            oldCodeHash: H256;
+        }>;
+        /**
+         * A contract was called either by a plain account or another contract.
+         *
+         * # Note
+         *
+         * Please keep in mind that like all events this is only emitted for successful
+         * calls. This is because on failure all storage changes including events are
+         * rolled back.
+         **/
+        Called: GenericPalletEvent<'Contracts', 'Called', {
+            /**
+             * The caller of the `contract`.
+             **/
+            caller: PalletContractsOrigin;
+            /**
+             * The contract that was called.
+             **/
+            contract: AccountId32;
+        }>;
+        /**
+         * A contract delegate called a code hash.
+         *
+         * # Note
+         *
+         * Please keep in mind that like all events this is only emitted for successful
+         * calls. This is because on failure all storage changes including events are
+         * rolled back.
+         **/
+        DelegateCalled: GenericPalletEvent<'Contracts', 'DelegateCalled', {
+            /**
+             * The contract that performed the delegate call and hence in whose context
+             * the `code_hash` is executed.
+             **/
+            contract: AccountId32;
+            /**
+             * The code hash that was delegate called.
+             **/
+            codeHash: H256;
+        }>;
+        /**
+         * Some funds have been transferred and held as storage deposit.
+         **/
+        StorageDepositTransferredAndHeld: GenericPalletEvent<'Contracts', 'StorageDepositTransferredAndHeld', {
+            from: AccountId32;
+            to: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some storage deposit funds have been transferred and released.
+         **/
+        StorageDepositTransferredAndReleased: GenericPalletEvent<'Contracts', 'StorageDepositTransferredAndReleased', {
+            from: AccountId32;
+            to: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Sudo`'s events
+     **/
+    sudo: {
+        /**
+         * A sudo just took place. \[result\]
+         **/
+        Sudid: GenericPalletEvent<'Sudo', 'Sudid', {
+            sudoResult: Result<[], DispatchError>;
+        }>;
+        /**
+         * The \[sudoer\] just switched identity; the old key is supplied if one existed.
+         **/
+        KeyChanged: GenericPalletEvent<'Sudo', 'KeyChanged', {
+            oldSudoer?: AccountId32 | undefined;
+        }>;
+        /**
+         * A sudo just took place. \[result\]
+         **/
+        SudoAsDone: GenericPalletEvent<'Sudo', 'SudoAsDone', {
+            sudoResult: Result<[], DispatchError>;
+        }>;
+        /**
+         * 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 `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 `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 `Glutton`'s events
+     **/
+    glutton: {
+        /**
+         * The pallet has been (re)initialized.
+         **/
+        PalletInitialized: GenericPalletEvent<'Glutton', 'PalletInitialized', {
+            /**
+             * Whether the pallet has been re-initialized.
+             **/
+            reinit: boolean;
+        }>;
+        /**
+         * The computation limit has been updated.
+         **/
+        ComputationLimitSet: GenericPalletEvent<'Glutton', 'ComputationLimitSet', {
+            /**
+             * The computation limit.
+             **/
+            compute: FixedU64;
+        }>;
+        /**
+         * The storage limit has been updated.
+         **/
+        StorageLimitSet: GenericPalletEvent<'Glutton', 'StorageLimitSet', {
+            /**
+             * The storage limit.
+             **/
+            storage: FixedU64;
+        }>;
+        /**
+         * 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 `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: KitchensinkRuntimeProxyType;
+            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: KitchensinkRuntimeProxyType;
+            delay: number;
+        }>;
+        /**
+         * A proxy was removed.
+         **/
+        ProxyRemoved: GenericPalletEvent<'Proxy', 'ProxyRemoved', {
+            delegator: AccountId32;
+            delegatee: AccountId32;
+            proxyType: KitchensinkRuntimeProxyType;
+            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 `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;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Tips`'s events
+     **/
+    tips: {
+        /**
+         * A new tip suggestion has been opened.
+         **/
+        NewTip: GenericPalletEvent<'Tips', 'NewTip', {
+            tipHash: H256;
+        }>;
+        /**
+         * A tip suggestion has reached threshold and is closing.
+         **/
+        TipClosing: GenericPalletEvent<'Tips', 'TipClosing', {
+            tipHash: H256;
+        }>;
+        /**
+         * A tip suggestion has been closed.
+         **/
+        TipClosed: GenericPalletEvent<'Tips', 'TipClosed', {
+            tipHash: H256;
+            who: AccountId32;
+            payout: bigint;
+        }>;
+        /**
+         * A tip suggestion has been retracted.
+         **/
+        TipRetracted: GenericPalletEvent<'Tips', 'TipRetracted', {
+            tipHash: H256;
+        }>;
+        /**
+         * A tip suggestion has been slashed.
+         **/
+        TipSlashed: GenericPalletEvent<'Tips', 'TipSlashed', {
+            tipHash: H256;
+            finder: AccountId32;
+            deposit: bigint;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Assets`'s events
+     **/
+    assets: {
+        /**
+         * Some asset class was created.
+         **/
+        Created: GenericPalletEvent<'Assets', 'Created', {
+            assetId: number;
+            creator: AccountId32;
+            owner: AccountId32;
+        }>;
+        /**
+         * Some assets were issued.
+         **/
+        Issued: GenericPalletEvent<'Assets', 'Issued', {
+            assetId: number;
+            owner: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some assets were transferred.
+         **/
+        Transferred: GenericPalletEvent<'Assets', 'Transferred', {
+            assetId: number;
+            from: AccountId32;
+            to: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some assets were destroyed.
+         **/
+        Burned: GenericPalletEvent<'Assets', 'Burned', {
+            assetId: number;
+            owner: AccountId32;
+            balance: bigint;
+        }>;
+        /**
+         * The management team changed.
+         **/
+        TeamChanged: GenericPalletEvent<'Assets', 'TeamChanged', {
+            assetId: number;
+            issuer: AccountId32;
+            admin: AccountId32;
+            freezer: AccountId32;
+        }>;
+        /**
+         * The owner changed.
+         **/
+        OwnerChanged: GenericPalletEvent<'Assets', 'OwnerChanged', {
+            assetId: number;
+            owner: AccountId32;
+        }>;
+        /**
+         * Some account `who` was frozen.
+         **/
+        Frozen: GenericPalletEvent<'Assets', 'Frozen', {
+            assetId: number;
+            who: AccountId32;
+        }>;
+        /**
+         * Some account `who` was thawed.
+         **/
+        Thawed: GenericPalletEvent<'Assets', 'Thawed', {
+            assetId: number;
+            who: AccountId32;
+        }>;
+        /**
+         * Some asset `asset_id` was frozen.
+         **/
+        AssetFrozen: GenericPalletEvent<'Assets', 'AssetFrozen', {
+            assetId: number;
+        }>;
+        /**
+         * Some asset `asset_id` was thawed.
+         **/
+        AssetThawed: GenericPalletEvent<'Assets', 'AssetThawed', {
+            assetId: number;
+        }>;
+        /**
+         * Accounts were destroyed for given asset.
+         **/
+        AccountsDestroyed: GenericPalletEvent<'Assets', 'AccountsDestroyed', {
+            assetId: number;
+            accountsDestroyed: number;
+            accountsRemaining: number;
+        }>;
+        /**
+         * Approvals were destroyed for given asset.
+         **/
+        ApprovalsDestroyed: GenericPalletEvent<'Assets', 'ApprovalsDestroyed', {
+            assetId: number;
+            approvalsDestroyed: number;
+            approvalsRemaining: number;
+        }>;
+        /**
+         * An asset class is in the process of being destroyed.
+         **/
+        DestructionStarted: GenericPalletEvent<'Assets', 'DestructionStarted', {
+            assetId: number;
+        }>;
+        /**
+         * An asset class was destroyed.
+         **/
+        Destroyed: GenericPalletEvent<'Assets', 'Destroyed', {
+            assetId: number;
+        }>;
+        /**
+         * Some asset class was force-created.
+         **/
+        ForceCreated: GenericPalletEvent<'Assets', 'ForceCreated', {
+            assetId: number;
+            owner: AccountId32;
+        }>;
+        /**
+         * New metadata has been set for an asset.
+         **/
+        MetadataSet: GenericPalletEvent<'Assets', 'MetadataSet', {
+            assetId: number;
+            name: Bytes;
+            symbol: Bytes;
+            decimals: number;
+            isFrozen: boolean;
+        }>;
+        /**
+         * Metadata has been cleared for an asset.
+         **/
+        MetadataCleared: GenericPalletEvent<'Assets', 'MetadataCleared', {
+            assetId: number;
+        }>;
+        /**
+         * (Additional) funds have been approved for transfer to a destination account.
+         **/
+        ApprovedTransfer: GenericPalletEvent<'Assets', 'ApprovedTransfer', {
+            assetId: number;
+            source: AccountId32;
+            delegate: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An approval for account `delegate` was cancelled by `owner`.
+         **/
+        ApprovalCancelled: GenericPalletEvent<'Assets', 'ApprovalCancelled', {
+            assetId: number;
+            owner: AccountId32;
+            delegate: AccountId32;
+        }>;
+        /**
+         * An `amount` was transferred in its entirety from `owner` to `destination` by
+         * the approved `delegate`.
+         **/
+        TransferredApproved: GenericPalletEvent<'Assets', 'TransferredApproved', {
+            assetId: number;
+            owner: AccountId32;
+            delegate: AccountId32;
+            destination: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An asset has had its attributes changed by the `Force` origin.
+         **/
+        AssetStatusChanged: GenericPalletEvent<'Assets', 'AssetStatusChanged', {
+            assetId: number;
+        }>;
+        /**
+         * The min_balance of an asset has been updated by the asset owner.
+         **/
+        AssetMinBalanceChanged: GenericPalletEvent<'Assets', 'AssetMinBalanceChanged', {
+            assetId: number;
+            newMinBalance: bigint;
+        }>;
+        /**
+         * Some account `who` was created with a deposit from `depositor`.
+         **/
+        Touched: GenericPalletEvent<'Assets', 'Touched', {
+            assetId: number;
+            who: AccountId32;
+            depositor: AccountId32;
+        }>;
+        /**
+         * Some account `who` was blocked.
+         **/
+        Blocked: GenericPalletEvent<'Assets', 'Blocked', {
+            assetId: number;
+            who: AccountId32;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `PoolAssets`'s events
+     **/
+    poolAssets: {
+        /**
+         * Some asset class was created.
+         **/
+        Created: GenericPalletEvent<'PoolAssets', 'Created', {
+            assetId: number;
+            creator: AccountId32;
+            owner: AccountId32;
+        }>;
+        /**
+         * Some assets were issued.
+         **/
+        Issued: GenericPalletEvent<'PoolAssets', 'Issued', {
+            assetId: number;
+            owner: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some assets were transferred.
+         **/
+        Transferred: GenericPalletEvent<'PoolAssets', 'Transferred', {
+            assetId: number;
+            from: AccountId32;
+            to: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some assets were destroyed.
+         **/
+        Burned: GenericPalletEvent<'PoolAssets', 'Burned', {
+            assetId: number;
+            owner: AccountId32;
+            balance: bigint;
+        }>;
+        /**
+         * The management team changed.
+         **/
+        TeamChanged: GenericPalletEvent<'PoolAssets', 'TeamChanged', {
+            assetId: number;
+            issuer: AccountId32;
+            admin: AccountId32;
+            freezer: AccountId32;
+        }>;
+        /**
+         * The owner changed.
+         **/
+        OwnerChanged: GenericPalletEvent<'PoolAssets', 'OwnerChanged', {
+            assetId: number;
+            owner: AccountId32;
+        }>;
+        /**
+         * Some account `who` was frozen.
+         **/
+        Frozen: GenericPalletEvent<'PoolAssets', 'Frozen', {
+            assetId: number;
+            who: AccountId32;
+        }>;
+        /**
+         * Some account `who` was thawed.
+         **/
+        Thawed: GenericPalletEvent<'PoolAssets', 'Thawed', {
+            assetId: number;
+            who: AccountId32;
+        }>;
+        /**
+         * Some asset `asset_id` was frozen.
+         **/
+        AssetFrozen: GenericPalletEvent<'PoolAssets', 'AssetFrozen', {
+            assetId: number;
+        }>;
+        /**
+         * Some asset `asset_id` was thawed.
+         **/
+        AssetThawed: GenericPalletEvent<'PoolAssets', 'AssetThawed', {
+            assetId: number;
+        }>;
+        /**
+         * Accounts were destroyed for given asset.
+         **/
+        AccountsDestroyed: GenericPalletEvent<'PoolAssets', 'AccountsDestroyed', {
+            assetId: number;
+            accountsDestroyed: number;
+            accountsRemaining: number;
+        }>;
+        /**
+         * Approvals were destroyed for given asset.
+         **/
+        ApprovalsDestroyed: GenericPalletEvent<'PoolAssets', 'ApprovalsDestroyed', {
+            assetId: number;
+            approvalsDestroyed: number;
+            approvalsRemaining: number;
+        }>;
+        /**
+         * An asset class is in the process of being destroyed.
+         **/
+        DestructionStarted: GenericPalletEvent<'PoolAssets', 'DestructionStarted', {
+            assetId: number;
+        }>;
+        /**
+         * An asset class was destroyed.
+         **/
+        Destroyed: GenericPalletEvent<'PoolAssets', 'Destroyed', {
+            assetId: number;
+        }>;
+        /**
+         * Some asset class was force-created.
+         **/
+        ForceCreated: GenericPalletEvent<'PoolAssets', 'ForceCreated', {
+            assetId: number;
+            owner: AccountId32;
+        }>;
+        /**
+         * New metadata has been set for an asset.
+         **/
+        MetadataSet: GenericPalletEvent<'PoolAssets', 'MetadataSet', {
+            assetId: number;
+            name: Bytes;
+            symbol: Bytes;
+            decimals: number;
+            isFrozen: boolean;
+        }>;
+        /**
+         * Metadata has been cleared for an asset.
+         **/
+        MetadataCleared: GenericPalletEvent<'PoolAssets', 'MetadataCleared', {
+            assetId: number;
+        }>;
+        /**
+         * (Additional) funds have been approved for transfer to a destination account.
+         **/
+        ApprovedTransfer: GenericPalletEvent<'PoolAssets', 'ApprovedTransfer', {
+            assetId: number;
+            source: AccountId32;
+            delegate: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An approval for account `delegate` was cancelled by `owner`.
+         **/
+        ApprovalCancelled: GenericPalletEvent<'PoolAssets', 'ApprovalCancelled', {
+            assetId: number;
+            owner: AccountId32;
+            delegate: AccountId32;
+        }>;
+        /**
+         * An `amount` was transferred in its entirety from `owner` to `destination` by
+         * the approved `delegate`.
+         **/
+        TransferredApproved: GenericPalletEvent<'PoolAssets', 'TransferredApproved', {
+            assetId: number;
+            owner: AccountId32;
+            delegate: AccountId32;
+            destination: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An asset has had its attributes changed by the `Force` origin.
+         **/
+        AssetStatusChanged: GenericPalletEvent<'PoolAssets', 'AssetStatusChanged', {
+            assetId: number;
+        }>;
+        /**
+         * The min_balance of an asset has been updated by the asset owner.
+         **/
+        AssetMinBalanceChanged: GenericPalletEvent<'PoolAssets', 'AssetMinBalanceChanged', {
+            assetId: number;
+            newMinBalance: bigint;
+        }>;
+        /**
+         * Some account `who` was created with a deposit from `depositor`.
+         **/
+        Touched: GenericPalletEvent<'PoolAssets', 'Touched', {
+            assetId: number;
+            who: AccountId32;
+            depositor: AccountId32;
+        }>;
+        /**
+         * Some account `who` was blocked.
+         **/
+        Blocked: GenericPalletEvent<'PoolAssets', 'Blocked', {
+            assetId: number;
+            who: AccountId32;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Lottery`'s events
+     **/
+    lottery: {
+        /**
+         * A lottery has been started!
+         **/
+        LotteryStarted: GenericPalletEvent<'Lottery', 'LotteryStarted', null>;
+        /**
+         * A new set of calls have been set!
+         **/
+        CallsUpdated: GenericPalletEvent<'Lottery', 'CallsUpdated', null>;
+        /**
+         * A winner has been chosen!
+         **/
+        Winner: GenericPalletEvent<'Lottery', 'Winner', {
+            winner: AccountId32;
+            lotteryBalance: bigint;
+        }>;
+        /**
+         * A ticket has been bought!
+         **/
+        TicketBought: GenericPalletEvent<'Lottery', 'TicketBought', {
+            who: AccountId32;
+            callIndex: [number, 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 `Uniques`'s events
+     **/
+    uniques: {
+        /**
+         * A `collection` was created.
+         **/
+        Created: GenericPalletEvent<'Uniques', 'Created', {
+            collection: number;
+            creator: AccountId32;
+            owner: AccountId32;
+        }>;
+        /**
+         * A `collection` was force-created.
+         **/
+        ForceCreated: GenericPalletEvent<'Uniques', 'ForceCreated', {
+            collection: number;
+            owner: AccountId32;
+        }>;
+        /**
+         * A `collection` was destroyed.
+         **/
+        Destroyed: GenericPalletEvent<'Uniques', 'Destroyed', {
+            collection: number;
+        }>;
+        /**
+         * An `item` was issued.
+         **/
+        Issued: GenericPalletEvent<'Uniques', 'Issued', {
+            collection: number;
+            item: number;
+            owner: AccountId32;
+        }>;
+        /**
+         * An `item` was transferred.
+         **/
+        Transferred: GenericPalletEvent<'Uniques', 'Transferred', {
+            collection: number;
+            item: number;
+            from: AccountId32;
+            to: AccountId32;
+        }>;
+        /**
+         * An `item` was destroyed.
+         **/
+        Burned: GenericPalletEvent<'Uniques', 'Burned', {
+            collection: number;
+            item: number;
+            owner: AccountId32;
+        }>;
+        /**
+         * Some `item` was frozen.
+         **/
+        Frozen: GenericPalletEvent<'Uniques', 'Frozen', {
+            collection: number;
+            item: number;
+        }>;
+        /**
+         * Some `item` was thawed.
+         **/
+        Thawed: GenericPalletEvent<'Uniques', 'Thawed', {
+            collection: number;
+            item: number;
+        }>;
+        /**
+         * Some `collection` was frozen.
+         **/
+        CollectionFrozen: GenericPalletEvent<'Uniques', 'CollectionFrozen', {
+            collection: number;
+        }>;
+        /**
+         * Some `collection` was thawed.
+         **/
+        CollectionThawed: GenericPalletEvent<'Uniques', 'CollectionThawed', {
+            collection: number;
+        }>;
+        /**
+         * The owner changed.
+         **/
+        OwnerChanged: GenericPalletEvent<'Uniques', 'OwnerChanged', {
+            collection: number;
+            newOwner: AccountId32;
+        }>;
+        /**
+         * The management team changed.
+         **/
+        TeamChanged: GenericPalletEvent<'Uniques', 'TeamChanged', {
+            collection: number;
+            issuer: AccountId32;
+            admin: AccountId32;
+            freezer: AccountId32;
+        }>;
+        /**
+         * An `item` of a `collection` has been approved by the `owner` for transfer by
+         * a `delegate`.
+         **/
+        ApprovedTransfer: GenericPalletEvent<'Uniques', 'ApprovedTransfer', {
+            collection: number;
+            item: number;
+            owner: AccountId32;
+            delegate: AccountId32;
+        }>;
+        /**
+         * An approval for a `delegate` account to transfer the `item` of an item
+         * `collection` was cancelled by its `owner`.
+         **/
+        ApprovalCancelled: GenericPalletEvent<'Uniques', 'ApprovalCancelled', {
+            collection: number;
+            item: number;
+            owner: AccountId32;
+            delegate: AccountId32;
+        }>;
+        /**
+         * A `collection` has had its attributes changed by the `Force` origin.
+         **/
+        ItemStatusChanged: GenericPalletEvent<'Uniques', 'ItemStatusChanged', {
+            collection: number;
+        }>;
+        /**
+         * New metadata has been set for a `collection`.
+         **/
+        CollectionMetadataSet: GenericPalletEvent<'Uniques', 'CollectionMetadataSet', {
+            collection: number;
+            data: Bytes;
+            isFrozen: boolean;
+        }>;
+        /**
+         * Metadata has been cleared for a `collection`.
+         **/
+        CollectionMetadataCleared: GenericPalletEvent<'Uniques', 'CollectionMetadataCleared', {
+            collection: number;
+        }>;
+        /**
+         * New metadata has been set for an item.
+         **/
+        MetadataSet: GenericPalletEvent<'Uniques', 'MetadataSet', {
+            collection: number;
+            item: number;
+            data: Bytes;
+            isFrozen: boolean;
+        }>;
+        /**
+         * Metadata has been cleared for an item.
+         **/
+        MetadataCleared: GenericPalletEvent<'Uniques', 'MetadataCleared', {
+            collection: number;
+            item: number;
+        }>;
+        /**
+         * Metadata has been cleared for an item.
+         **/
+        Redeposited: GenericPalletEvent<'Uniques', 'Redeposited', {
+            collection: number;
+            successfulItems: Array<number>;
+        }>;
+        /**
+         * New attribute metadata has been set for a `collection` or `item`.
+         **/
+        AttributeSet: GenericPalletEvent<'Uniques', 'AttributeSet', {
+            collection: number;
+            maybeItem?: number | undefined;
+            key: Bytes;
+            value: Bytes;
+        }>;
+        /**
+         * Attribute metadata has been cleared for a `collection` or `item`.
+         **/
+        AttributeCleared: GenericPalletEvent<'Uniques', 'AttributeCleared', {
+            collection: number;
+            maybeItem?: number | undefined;
+            key: Bytes;
+        }>;
+        /**
+         * Ownership acceptance has changed for an account.
+         **/
+        OwnershipAcceptanceChanged: GenericPalletEvent<'Uniques', 'OwnershipAcceptanceChanged', {
+            who: AccountId32;
+            maybeCollection?: number | undefined;
+        }>;
+        /**
+         * Max supply has been set for a collection.
+         **/
+        CollectionMaxSupplySet: GenericPalletEvent<'Uniques', 'CollectionMaxSupplySet', {
+            collection: number;
+            maxSupply: number;
+        }>;
+        /**
+         * The price was set for the instance.
+         **/
+        ItemPriceSet: GenericPalletEvent<'Uniques', 'ItemPriceSet', {
+            collection: number;
+            item: number;
+            price: bigint;
+            whitelistedBuyer?: AccountId32 | undefined;
+        }>;
+        /**
+         * The price for the instance was removed.
+         **/
+        ItemPriceRemoved: GenericPalletEvent<'Uniques', 'ItemPriceRemoved', {
+            collection: number;
+            item: number;
+        }>;
+        /**
+         * An item was bought.
+         **/
+        ItemBought: GenericPalletEvent<'Uniques', 'ItemBought', {
+            collection: number;
+            item: number;
+            price: bigint;
+            seller: AccountId32;
+            buyer: AccountId32;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Nfts`'s events
+     **/
+    nfts: {
+        /**
+         * A `collection` was created.
+         **/
+        Created: GenericPalletEvent<'Nfts', 'Created', {
+            collection: number;
+            creator: AccountId32;
+            owner: AccountId32;
+        }>;
+        /**
+         * A `collection` was force-created.
+         **/
+        ForceCreated: GenericPalletEvent<'Nfts', 'ForceCreated', {
+            collection: number;
+            owner: AccountId32;
+        }>;
+        /**
+         * A `collection` was destroyed.
+         **/
+        Destroyed: GenericPalletEvent<'Nfts', 'Destroyed', {
+            collection: number;
+        }>;
+        /**
+         * An `item` was issued.
+         **/
+        Issued: GenericPalletEvent<'Nfts', 'Issued', {
+            collection: number;
+            item: number;
+            owner: AccountId32;
+        }>;
+        /**
+         * An `item` was transferred.
+         **/
+        Transferred: GenericPalletEvent<'Nfts', 'Transferred', {
+            collection: number;
+            item: number;
+            from: AccountId32;
+            to: AccountId32;
+        }>;
+        /**
+         * An `item` was destroyed.
+         **/
+        Burned: GenericPalletEvent<'Nfts', 'Burned', {
+            collection: number;
+            item: number;
+            owner: AccountId32;
+        }>;
+        /**
+         * An `item` became non-transferable.
+         **/
+        ItemTransferLocked: GenericPalletEvent<'Nfts', 'ItemTransferLocked', {
+            collection: number;
+            item: number;
+        }>;
+        /**
+         * An `item` became transferable.
+         **/
+        ItemTransferUnlocked: GenericPalletEvent<'Nfts', 'ItemTransferUnlocked', {
+            collection: number;
+            item: number;
+        }>;
+        /**
+         * `item` metadata or attributes were locked.
+         **/
+        ItemPropertiesLocked: GenericPalletEvent<'Nfts', 'ItemPropertiesLocked', {
+            collection: number;
+            item: number;
+            lockMetadata: boolean;
+            lockAttributes: boolean;
+        }>;
+        /**
+         * Some `collection` was locked.
+         **/
+        CollectionLocked: GenericPalletEvent<'Nfts', 'CollectionLocked', {
+            collection: number;
+        }>;
+        /**
+         * The owner changed.
+         **/
+        OwnerChanged: GenericPalletEvent<'Nfts', 'OwnerChanged', {
+            collection: number;
+            newOwner: AccountId32;
+        }>;
+        /**
+         * The management team changed.
+         **/
+        TeamChanged: GenericPalletEvent<'Nfts', 'TeamChanged', {
+            collection: number;
+            issuer?: AccountId32 | undefined;
+            admin?: AccountId32 | undefined;
+            freezer?: AccountId32 | undefined;
+        }>;
+        /**
+         * An `item` of a `collection` has been approved by the `owner` for transfer by
+         * a `delegate`.
+         **/
+        TransferApproved: GenericPalletEvent<'Nfts', 'TransferApproved', {
+            collection: number;
+            item: number;
+            owner: AccountId32;
+            delegate: AccountId32;
+            deadline?: number | undefined;
+        }>;
+        /**
+         * An approval for a `delegate` account to transfer the `item` of an item
+         * `collection` was cancelled by its `owner`.
+         **/
+        ApprovalCancelled: GenericPalletEvent<'Nfts', 'ApprovalCancelled', {
+            collection: number;
+            item: number;
+            owner: AccountId32;
+            delegate: AccountId32;
+        }>;
+        /**
+         * All approvals of an item got cancelled.
+         **/
+        AllApprovalsCancelled: GenericPalletEvent<'Nfts', 'AllApprovalsCancelled', {
+            collection: number;
+            item: number;
+            owner: AccountId32;
+        }>;
+        /**
+         * A `collection` has had its config changed by the `Force` origin.
+         **/
+        CollectionConfigChanged: GenericPalletEvent<'Nfts', 'CollectionConfigChanged', {
+            collection: number;
+        }>;
+        /**
+         * New metadata has been set for a `collection`.
+         **/
+        CollectionMetadataSet: GenericPalletEvent<'Nfts', 'CollectionMetadataSet', {
+            collection: number;
+            data: Bytes;
+        }>;
+        /**
+         * Metadata has been cleared for a `collection`.
+         **/
+        CollectionMetadataCleared: GenericPalletEvent<'Nfts', 'CollectionMetadataCleared', {
+            collection: number;
+        }>;
+        /**
+         * New metadata has been set for an item.
+         **/
+        ItemMetadataSet: GenericPalletEvent<'Nfts', 'ItemMetadataSet', {
+            collection: number;
+            item: number;
+            data: Bytes;
+        }>;
+        /**
+         * Metadata has been cleared for an item.
+         **/
+        ItemMetadataCleared: GenericPalletEvent<'Nfts', 'ItemMetadataCleared', {
+            collection: number;
+            item: number;
+        }>;
+        /**
+         * The deposit for a set of `item`s within a `collection` has been updated.
+         **/
+        Redeposited: GenericPalletEvent<'Nfts', 'Redeposited', {
+            collection: number;
+            successfulItems: Array<number>;
+        }>;
+        /**
+         * New attribute metadata has been set for a `collection` or `item`.
+         **/
+        AttributeSet: GenericPalletEvent<'Nfts', 'AttributeSet', {
+            collection: number;
+            maybeItem?: number | undefined;
+            key: Bytes;
+            value: Bytes;
+            namespace: PalletNftsAttributeNamespace;
+        }>;
+        /**
+         * Attribute metadata has been cleared for a `collection` or `item`.
+         **/
+        AttributeCleared: GenericPalletEvent<'Nfts', 'AttributeCleared', {
+            collection: number;
+            maybeItem?: number | undefined;
+            key: Bytes;
+            namespace: PalletNftsAttributeNamespace;
+        }>;
+        /**
+         * A new approval to modify item attributes was added.
+         **/
+        ItemAttributesApprovalAdded: GenericPalletEvent<'Nfts', 'ItemAttributesApprovalAdded', {
+            collection: number;
+            item: number;
+            delegate: AccountId32;
+        }>;
+        /**
+         * A new approval to modify item attributes was removed.
+         **/
+        ItemAttributesApprovalRemoved: GenericPalletEvent<'Nfts', 'ItemAttributesApprovalRemoved', {
+            collection: number;
+            item: number;
+            delegate: AccountId32;
+        }>;
+        /**
+         * Ownership acceptance has changed for an account.
+         **/
+        OwnershipAcceptanceChanged: GenericPalletEvent<'Nfts', 'OwnershipAcceptanceChanged', {
+            who: AccountId32;
+            maybeCollection?: number | undefined;
+        }>;
+        /**
+         * Max supply has been set for a collection.
+         **/
+        CollectionMaxSupplySet: GenericPalletEvent<'Nfts', 'CollectionMaxSupplySet', {
+            collection: number;
+            maxSupply: number;
+        }>;
+        /**
+         * Mint settings for a collection had changed.
+         **/
+        CollectionMintSettingsUpdated: GenericPalletEvent<'Nfts', 'CollectionMintSettingsUpdated', {
+            collection: number;
+        }>;
+        /**
+         * Event gets emitted when the `NextCollectionId` gets incremented.
+         **/
+        NextCollectionIdIncremented: GenericPalletEvent<'Nfts', 'NextCollectionIdIncremented', {
+            nextId?: number | undefined;
+        }>;
+        /**
+         * The price was set for the item.
+         **/
+        ItemPriceSet: GenericPalletEvent<'Nfts', 'ItemPriceSet', {
+            collection: number;
+            item: number;
+            price: bigint;
+            whitelistedBuyer?: AccountId32 | undefined;
+        }>;
+        /**
+         * The price for the item was removed.
+         **/
+        ItemPriceRemoved: GenericPalletEvent<'Nfts', 'ItemPriceRemoved', {
+            collection: number;
+            item: number;
+        }>;
+        /**
+         * An item was bought.
+         **/
+        ItemBought: GenericPalletEvent<'Nfts', 'ItemBought', {
+            collection: number;
+            item: number;
+            price: bigint;
+            seller: AccountId32;
+            buyer: AccountId32;
+        }>;
+        /**
+         * A tip was sent.
+         **/
+        TipSent: GenericPalletEvent<'Nfts', 'TipSent', {
+            collection: number;
+            item: number;
+            sender: AccountId32;
+            receiver: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An `item` swap intent was created.
+         **/
+        SwapCreated: GenericPalletEvent<'Nfts', 'SwapCreated', {
+            offeredCollection: number;
+            offeredItem: number;
+            desiredCollection: number;
+            desiredItem?: number | undefined;
+            price?: PalletNftsPriceWithDirection | undefined;
+            deadline: number;
+        }>;
+        /**
+         * The swap was cancelled.
+         **/
+        SwapCancelled: GenericPalletEvent<'Nfts', 'SwapCancelled', {
+            offeredCollection: number;
+            offeredItem: number;
+            desiredCollection: number;
+            desiredItem?: number | undefined;
+            price?: PalletNftsPriceWithDirection | undefined;
+            deadline: number;
+        }>;
+        /**
+         * The swap has been claimed.
+         **/
+        SwapClaimed: GenericPalletEvent<'Nfts', 'SwapClaimed', {
+            sentCollection: number;
+            sentItem: number;
+            sentItemOwner: AccountId32;
+            receivedCollection: number;
+            receivedItem: number;
+            receivedItemOwner: AccountId32;
+            price?: PalletNftsPriceWithDirection | undefined;
+            deadline: number;
+        }>;
+        /**
+         * New attributes have been set for an `item` of the `collection`.
+         **/
+        PreSignedAttributesSet: GenericPalletEvent<'Nfts', 'PreSignedAttributesSet', {
+            collection: number;
+            item: number;
+            namespace: PalletNftsAttributeNamespace;
+        }>;
+        /**
+         * A new attribute in the `Pallet` namespace was set for the `collection` or an `item`
+         * within that `collection`.
+         **/
+        PalletAttributeSet: GenericPalletEvent<'Nfts', 'PalletAttributeSet', {
+            collection: number;
+            item?: number | undefined;
+            attribute: PalletNftsPalletAttributes;
+            value: Bytes;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `NftFractionalization`'s events
+     **/
+    nftFractionalization: {
+        /**
+         * An NFT was successfully fractionalized.
+         **/
+        NftFractionalized: GenericPalletEvent<'NftFractionalization', 'NftFractionalized', {
+            nftCollection: number;
+            nft: number;
+            fractions: bigint;
+            asset: number;
+            beneficiary: AccountId32;
+        }>;
+        /**
+         * An NFT was successfully returned back.
+         **/
+        NftUnified: GenericPalletEvent<'NftFractionalization', 'NftUnified', {
+            nftCollection: number;
+            nft: number;
+            asset: number;
+            beneficiary: AccountId32;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Salary`'s events
+     **/
+    salary: {
+        /**
+         * A member is inducted into the payroll.
+         **/
+        Inducted: GenericPalletEvent<'Salary', 'Inducted', {
+            who: AccountId32;
+        }>;
+        /**
+         * A member registered for a payout.
+         **/
+        Registered: GenericPalletEvent<'Salary', 'Registered', {
+            who: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * A payment happened.
+         **/
+        Paid: GenericPalletEvent<'Salary', 'Paid', {
+            who: AccountId32;
+            beneficiary: AccountId32;
+            amount: bigint;
+            id: [];
+        }>;
+        /**
+         * The next cycle begins.
+         **/
+        CycleStarted: GenericPalletEvent<'Salary', 'CycleStarted', {
+            index: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `CoreFellowship`'s events
+     **/
+    coreFellowship: {
+        /**
+         * Parameters for the pallet have changed.
+         **/
+        ParamsChanged: GenericPalletEvent<'CoreFellowship', 'ParamsChanged', {
+            params: PalletCoreFellowshipParamsType;
+        }>;
+        /**
+         * Member activity flag has been set.
+         **/
+        ActiveChanged: GenericPalletEvent<'CoreFellowship', 'ActiveChanged', {
+            who: AccountId32;
+            isActive: boolean;
+        }>;
+        /**
+         * Member has begun being tracked in this pallet.
+         **/
+        Inducted: GenericPalletEvent<'CoreFellowship', 'Inducted', {
+            who: AccountId32;
+        }>;
+        /**
+         * Member has been removed from being tracked in this pallet (i.e. because rank is now
+         * zero).
+         **/
+        Offboarded: GenericPalletEvent<'CoreFellowship', 'Offboarded', {
+            who: AccountId32;
+        }>;
+        /**
+         * Member has been promoted to the given rank.
+         **/
+        Promoted: GenericPalletEvent<'CoreFellowship', 'Promoted', {
+            who: AccountId32;
+            toRank: number;
+        }>;
+        /**
+         * Member has been demoted to the given (non-zero) rank.
+         **/
+        Demoted: GenericPalletEvent<'CoreFellowship', 'Demoted', {
+            who: AccountId32;
+            toRank: number;
+        }>;
+        /**
+         * Member has been proven at their current rank, postponing auto-demotion.
+         **/
+        Proven: GenericPalletEvent<'CoreFellowship', 'Proven', {
+            who: AccountId32;
+            atRank: number;
+        }>;
+        /**
+         * Member has stated evidence of their efforts their request for rank.
+         **/
+        Requested: GenericPalletEvent<'CoreFellowship', 'Requested', {
+            who: AccountId32;
+            wish: PalletCoreFellowshipWish;
+        }>;
+        /**
+         * Some submitted evidence was judged and removed. There may or may not have been a change
+         * to the rank, but in any case, `last_proof` is reset.
+         **/
+        EvidenceJudged: GenericPalletEvent<'CoreFellowship', 'EvidenceJudged', {
+            /**
+             * The member/candidate.
+             **/
+            who: AccountId32;
+            /**
+             * The desired outcome for which the evidence was presented.
+             **/
+            wish: PalletCoreFellowshipWish;
+            /**
+             * The evidence of efforts.
+             **/
+            evidence: Bytes;
+            /**
+             * The old rank, prior to this change.
+             **/
+            oldRank: number;
+            /**
+             * New rank. If `None` then candidate record was removed entirely.
+             **/
+            newRank?: number | undefined;
+        }>;
+        /**
+         * Pre-ranked account has been inducted at their current rank.
+         **/
+        Imported: GenericPalletEvent<'CoreFellowship', 'Imported', {
+            who: AccountId32;
+            rank: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `TransactionStorage`'s events
+     **/
+    transactionStorage: {
+        /**
+         * Stored data under specified index.
+         **/
+        Stored: GenericPalletEvent<'TransactionStorage', 'Stored', {
+            index: number;
+        }>;
+        /**
+         * Renewed data under specified index.
+         **/
+        Renewed: GenericPalletEvent<'TransactionStorage', 'Renewed', {
+            index: number;
+        }>;
+        /**
+         * Storage proof was successfully checked.
+         **/
+        ProofChecked: GenericPalletEvent<'TransactionStorage', 'ProofChecked', null>;
+        /**
+         * 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 `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 `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 `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 `Remark`'s events
+     **/
+    remark: {
+        /**
+         * Stored data off chain.
+         **/
+        Stored: GenericPalletEvent<'Remark', 'Stored', {
+            sender: AccountId32;
+            contentHash: H256;
+        }>;
+        /**
+         * 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 `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 `AllianceMotion`'s events
+     **/
+    allianceMotion: {
+        /**
+         * A motion (given hash) has been proposed (by given account) with a threshold (given
+         * `MemberCount`).
+         **/
+        Proposed: GenericPalletEvent<'AllianceMotion', 'Proposed', {
+            account: AccountId32;
+            proposalIndex: number;
+            proposalHash: H256;
+            threshold: number;
+        }>;
+        /**
+         * A motion (given hash) has been voted on by given account, leaving
+         * a tally (yes votes and no votes given respectively as `MemberCount`).
+         **/
+        Voted: GenericPalletEvent<'AllianceMotion', 'Voted', {
+            account: AccountId32;
+            proposalHash: H256;
+            voted: boolean;
+            yes: number;
+            no: number;
+        }>;
+        /**
+         * A motion was approved by the required threshold.
+         **/
+        Approved: GenericPalletEvent<'AllianceMotion', 'Approved', {
+            proposalHash: H256;
+        }>;
+        /**
+         * A motion was not approved by the required threshold.
+         **/
+        Disapproved: GenericPalletEvent<'AllianceMotion', 'Disapproved', {
+            proposalHash: H256;
+        }>;
+        /**
+         * A motion was executed; result will be `Ok` if it returned without error.
+         **/
+        Executed: GenericPalletEvent<'AllianceMotion', 'Executed', {
+            proposalHash: H256;
+            result: Result<[], DispatchError>;
+        }>;
+        /**
+         * A single member did some action; result will be `Ok` if it returned without error.
+         **/
+        MemberExecuted: GenericPalletEvent<'AllianceMotion', 'MemberExecuted', {
+            proposalHash: H256;
+            result: Result<[], DispatchError>;
+        }>;
+        /**
+         * A proposal was closed because its threshold was reached or after its duration was up.
+         **/
+        Closed: GenericPalletEvent<'AllianceMotion', 'Closed', {
+            proposalHash: H256;
+            yes: number;
+            no: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Alliance`'s events
+     **/
+    alliance: {
+        /**
+         * A new rule has been set.
+         **/
+        NewRuleSet: GenericPalletEvent<'Alliance', 'NewRuleSet', {
+            rule: PalletAllianceCid;
+        }>;
+        /**
+         * A new announcement has been proposed.
+         **/
+        Announced: GenericPalletEvent<'Alliance', 'Announced', {
+            announcement: PalletAllianceCid;
+        }>;
+        /**
+         * An on-chain announcement has been removed.
+         **/
+        AnnouncementRemoved: GenericPalletEvent<'Alliance', 'AnnouncementRemoved', {
+            announcement: PalletAllianceCid;
+        }>;
+        /**
+         * Some accounts have been initialized as members (fellows/allies).
+         **/
+        MembersInitialized: GenericPalletEvent<'Alliance', 'MembersInitialized', {
+            fellows: Array<AccountId32>;
+            allies: Array<AccountId32>;
+        }>;
+        /**
+         * An account has been added as an Ally and reserved its deposit.
+         **/
+        NewAllyJoined: GenericPalletEvent<'Alliance', 'NewAllyJoined', {
+            ally: AccountId32;
+            nominator?: AccountId32 | undefined;
+            reserved?: bigint | undefined;
+        }>;
+        /**
+         * An ally has been elevated to Fellow.
+         **/
+        AllyElevated: GenericPalletEvent<'Alliance', 'AllyElevated', {
+            ally: AccountId32;
+        }>;
+        /**
+         * A member gave retirement notice and their retirement period started.
+         **/
+        MemberRetirementPeriodStarted: GenericPalletEvent<'Alliance', 'MemberRetirementPeriodStarted', {
+            member: AccountId32;
+        }>;
+        /**
+         * A member has retired with its deposit unreserved.
+         **/
+        MemberRetired: GenericPalletEvent<'Alliance', 'MemberRetired', {
+            member: AccountId32;
+            unreserved?: bigint | undefined;
+        }>;
+        /**
+         * A member has been kicked out with its deposit slashed.
+         **/
+        MemberKicked: GenericPalletEvent<'Alliance', 'MemberKicked', {
+            member: AccountId32;
+            slashed?: bigint | undefined;
+        }>;
+        /**
+         * Accounts or websites have been added into the list of unscrupulous items.
+         **/
+        UnscrupulousItemAdded: GenericPalletEvent<'Alliance', 'UnscrupulousItemAdded', {
+            items: Array<PalletAllianceUnscrupulousItem>;
+        }>;
+        /**
+         * Accounts or websites have been removed from the list of unscrupulous items.
+         **/
+        UnscrupulousItemRemoved: GenericPalletEvent<'Alliance', 'UnscrupulousItemRemoved', {
+            items: Array<PalletAllianceUnscrupulousItem>;
+        }>;
+        /**
+         * Alliance disbanded. Includes number deleted members and unreserved deposits.
+         **/
+        AllianceDisbanded: GenericPalletEvent<'Alliance', 'AllianceDisbanded', {
+            fellowMembers: number;
+            allyMembers: number;
+            unreserved: number;
+        }>;
+        /**
+         * A Fellow abdicated their voting rights. They are now an Ally.
+         **/
+        FellowAbdicated: GenericPalletEvent<'Alliance', 'FellowAbdicated', {
+            fellow: AccountId32;
+        }>;
+        /**
+         * 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;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `RankedPolls`'s events
+     **/
+    rankedPolls: {
+        /**
+         * A referendum has been submitted.
+         **/
+        Submitted: GenericPalletEvent<'RankedPolls', '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<'RankedPolls', '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<'RankedPolls', '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<'RankedPolls', '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<'RankedPolls', '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<'RankedPolls', 'ConfirmStarted', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+        }>;
+        ConfirmAborted: GenericPalletEvent<'RankedPolls', 'ConfirmAborted', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+        }>;
+        /**
+         * A referendum has ended its confirmation phase and is ready for approval.
+         **/
+        Confirmed: GenericPalletEvent<'RankedPolls', '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<'RankedPolls', 'Approved', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+        }>;
+        /**
+         * A proposal has been rejected by referendum.
+         **/
+        Rejected: GenericPalletEvent<'RankedPolls', '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<'RankedPolls', 'TimedOut', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The final tally of votes in this referendum.
+             **/
+            tally: PalletRankedCollectiveTally;
+        }>;
+        /**
+         * A referendum has been cancelled.
+         **/
+        Cancelled: GenericPalletEvent<'RankedPolls', 'Cancelled', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * The final tally of votes in this referendum.
+             **/
+            tally: PalletRankedCollectiveTally;
+        }>;
+        /**
+         * A referendum has been killed.
+         **/
+        Killed: GenericPalletEvent<'RankedPolls', '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<'RankedPolls', '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<'RankedPolls', 'MetadataSet', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * Preimage hash.
+             **/
+            hash: H256;
+        }>;
+        /**
+         * Metadata for a referendum has been cleared.
+         **/
+        MetadataCleared: GenericPalletEvent<'RankedPolls', 'MetadataCleared', {
+            /**
+             * Index of the referendum.
+             **/
+            index: number;
+            /**
+             * Preimage hash.
+             **/
+            hash: H256;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `RankedCollective`'s events
+     **/
+    rankedCollective: {
+        /**
+         * A member `who` has been added.
+         **/
+        MemberAdded: GenericPalletEvent<'RankedCollective', 'MemberAdded', {
+            who: AccountId32;
+        }>;
+        /**
+         * The member `who`se rank has been changed to the given `rank`.
+         **/
+        RankChanged: GenericPalletEvent<'RankedCollective', 'RankChanged', {
+            who: AccountId32;
+            rank: number;
+        }>;
+        /**
+         * The member `who` of given `rank` has been removed from the collective.
+         **/
+        MemberRemoved: GenericPalletEvent<'RankedCollective', 'MemberRemoved', {
+            who: AccountId32;
+            rank: number;
+        }>;
+        /**
+         * The member `who` has voted for the `poll` with the given `vote` leading to an updated
+         * `tally`.
+         **/
+        Voted: GenericPalletEvent<'RankedCollective', 'Voted', {
+            who: AccountId32;
+            poll: number;
+            vote: PalletRankedCollectiveVoteRecord;
+            tally: PalletRankedCollectiveTally;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `AssetConversion`'s events
+     **/
+    assetConversion: {
+        /**
+         * A successful call of the `CretaPool` extrinsic will create this event.
+         **/
+        PoolCreated: GenericPalletEvent<'AssetConversion', 'PoolCreated', {
+            /**
+             * The account that created the pool.
+             **/
+            creator: AccountId32;
+            /**
+             * The pool id associated with the pool. Note that the order of the assets may not be
+             * the same as the order specified in the create pool extrinsic.
+             **/
+            poolId: [PalletAssetConversionNativeOrAssetId, PalletAssetConversionNativeOrAssetId];
+            /**
+             * The account ID of the pool.
+             **/
+            poolAccount: AccountId32;
+            /**
+             * The id of the liquidity tokens that will be minted when assets are added to this
+             * pool.
+             **/
+            lpToken: number;
+        }>;
+        /**
+         * A successful call of the `AddLiquidity` extrinsic will create this event.
+         **/
+        LiquidityAdded: GenericPalletEvent<'AssetConversion', 'LiquidityAdded', {
+            /**
+             * The account that the liquidity was taken from.
+             **/
+            who: AccountId32;
+            /**
+             * The account that the liquidity tokens were minted to.
+             **/
+            mintTo: AccountId32;
+            /**
+             * The pool id of the pool that the liquidity was added to.
+             **/
+            poolId: [PalletAssetConversionNativeOrAssetId, PalletAssetConversionNativeOrAssetId];
+            /**
+             * The amount of the first asset that was added to the pool.
+             **/
+            amount1Provided: bigint;
+            /**
+             * The amount of the second asset that was added to the pool.
+             **/
+            amount2Provided: bigint;
+            /**
+             * The id of the lp token that was minted.
+             **/
+            lpToken: number;
+            /**
+             * The amount of lp tokens that were minted of that id.
+             **/
+            lpTokenMinted: bigint;
+        }>;
+        /**
+         * A successful call of the `RemoveLiquidity` extrinsic will create this event.
+         **/
+        LiquidityRemoved: GenericPalletEvent<'AssetConversion', 'LiquidityRemoved', {
+            /**
+             * The account that the liquidity tokens were burned from.
+             **/
+            who: AccountId32;
+            /**
+             * The account that the assets were transferred to.
+             **/
+            withdrawTo: AccountId32;
+            /**
+             * The pool id that the liquidity was removed from.
+             **/
+            poolId: [PalletAssetConversionNativeOrAssetId, PalletAssetConversionNativeOrAssetId];
+            /**
+             * The amount of the first asset that was removed from the pool.
+             **/
+            amount1: bigint;
+            /**
+             * The amount of the second asset that was removed from the pool.
+             **/
+            amount2: bigint;
+            /**
+             * The id of the lp token that was burned.
+             **/
+            lpToken: number;
+            /**
+             * The amount of lp tokens that were burned of that id.
+             **/
+            lpTokenBurned: bigint;
+            /**
+             * Liquidity withdrawal fee (%).
+             **/
+            withdrawalFee: Permill;
+        }>;
+        /**
+         * Assets have been converted from one to another. Both `SwapExactTokenForToken`
+         * and `SwapTokenForExactToken` will generate this event.
+         **/
+        SwapExecuted: GenericPalletEvent<'AssetConversion', 'SwapExecuted', {
+            /**
+             * Which account was the instigator of the swap.
+             **/
+            who: AccountId32;
+            /**
+             * The account that the assets were transferred to.
+             **/
+            sendTo: AccountId32;
+            /**
+             * The route of asset ids that the swap went through.
+             * E.g. A -> Dot -> B
+             **/
+            path: Array<PalletAssetConversionNativeOrAssetId>;
+            /**
+             * The amount of the first asset that was swapped.
+             **/
+            amountIn: bigint;
+            /**
+             * The amount of the second asset that was received.
+             **/
+            amountOut: bigint;
+        }>;
+        /**
+         * An amount has been transferred from one account to another.
+         **/
+        Transfer: GenericPalletEvent<'AssetConversion', 'Transfer', {
+            /**
+             * The account that the assets were transferred from.
+             **/
+            from: AccountId32;
+            /**
+             * The account that the assets were transferred to.
+             **/
+            to: AccountId32;
+            /**
+             * The asset that was transferred.
+             **/
+            asset: PalletAssetConversionNativeOrAssetId;
+            /**
+             * The amount of the asset that was transferred.
+             **/
+            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 `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: number;
+            error: FrameSupportMessagesProcessMessageError;
+        }>;
+        /**
+         * Message is processed.
+         **/
+        Processed: GenericPalletEvent<'MessageQueue', 'Processed', {
+            id: FixedBytes<32>;
+            origin: number;
+            weightUsed: SpWeightsWeightV2Weight;
+            success: boolean;
+        }>;
+        /**
+         * Message placed in overweight queue.
+         **/
+        OverweightEnqueued: GenericPalletEvent<'MessageQueue', 'OverweightEnqueued', {
+            id: FixedBytes<32>;
+            origin: number;
+            pageIndex: number;
+            messageIndex: number;
+        }>;
+        /**
+         * This page was reaped.
+         **/
+        PageReaped: GenericPalletEvent<'MessageQueue', 'PageReaped', {
+            origin: number;
+            index: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Pov`'s events
+     **/
+    pov: {
+        TestEvent: GenericPalletEvent<'Pov', 'TestEvent', undefined>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `TxPause`'s events
+     **/
+    txPause: {
+        /**
+         * This pallet, or a specific call is now paused.
+         **/
+        CallPaused: GenericPalletEvent<'TxPause', 'CallPaused', {
+            fullName: [Bytes, Bytes];
+        }>;
+        /**
+         * This pallet, or a specific call is now unpaused.
+         **/
+        CallUnpaused: GenericPalletEvent<'TxPause', 'CallUnpaused', {
+            fullName: [Bytes, Bytes];
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `SafeMode`'s events
+     **/
+    safeMode: {
+        /**
+         * The safe-mode was entered until inclusively this block.
+         **/
+        Entered: GenericPalletEvent<'SafeMode', 'Entered', {
+            until: number;
+        }>;
+        /**
+         * The safe-mode was extended until inclusively this block.
+         **/
+        Extended: GenericPalletEvent<'SafeMode', 'Extended', {
+            until: number;
+        }>;
+        /**
+         * Exited the safe-mode for a specific reason.
+         **/
+        Exited: GenericPalletEvent<'SafeMode', 'Exited', {
+            reason: PalletSafeModeExitReason;
+        }>;
+        /**
+         * An account reserved funds for either entering or extending the safe-mode.
+         **/
+        DepositPlaced: GenericPalletEvent<'SafeMode', 'DepositPlaced', {
+            account: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An account had a reserve released that was reserved.
+         **/
+        DepositReleased: GenericPalletEvent<'SafeMode', 'DepositReleased', {
+            account: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An account had reserve slashed that was reserved.
+         **/
+        DepositSlashed: GenericPalletEvent<'SafeMode', 'DepositSlashed', {
+            account: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Could not hold funds for entering or extending the safe-mode.
+         *
+         * This error comes from the underlying `Currency`.
+         **/
+        CannotDeposit: GenericPalletEvent<'SafeMode', 'CannotDeposit', null>;
+        /**
+         * Could not release funds for entering or extending the safe-mode.
+         *
+         * This error comes from the underlying `Currency`.
+         **/
+        CannotRelease: GenericPalletEvent<'SafeMode', 'CannotRelease', null>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Statement`'s events
+     **/
+    statement: {
+        /**
+         * A new statement is submitted
+         **/
+        NewStatement: GenericPalletEvent<'Statement', 'NewStatement', {
+            account: AccountId32;
+            statement: SpStatementStoreStatement;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Broker`'s events
+     **/
+    broker: {
+        /**
+         * A Region of Bulk Coretime has been purchased.
+         **/
+        Purchased: GenericPalletEvent<'Broker', 'Purchased', {
+            /**
+             * The identity of the purchaser.
+             **/
+            who: AccountId32;
+            /**
+             * The identity of the Region.
+             **/
+            regionId: PalletBrokerRegionId;
+            /**
+             * The price paid for this Region.
+             **/
+            price: bigint;
+            /**
+             * The duration of the Region.
+             **/
+            duration: number;
+        }>;
+        /**
+         * The workload of a core has become renewable.
+         **/
+        Renewable: GenericPalletEvent<'Broker', 'Renewable', {
+            /**
+             * The core whose workload can be renewed.
+             **/
+            core: number;
+            /**
+             * The price at which the workload can be renewed.
+             **/
+            price: bigint;
+            /**
+             * The time at which the workload would recommence of this renewal. The call to renew
+             * cannot happen before the beginning of the interlude prior to the sale for regions
+             * which begin at this time.
+             **/
+            begin: number;
+            /**
+             * The actual workload which can be renewed.
+             **/
+            workload: Array<PalletBrokerScheduleItem>;
+        }>;
+        /**
+         * A workload has been renewed.
+         **/
+        Renewed: GenericPalletEvent<'Broker', 'Renewed', {
+            /**
+             * The identity of the renewer.
+             **/
+            who: AccountId32;
+            /**
+             * The price paid for this renewal.
+             **/
+            price: bigint;
+            /**
+             * The index of the core on which the `workload` was previously scheduled.
+             **/
+            oldCore: number;
+            /**
+             * The index of the core on which the renewed `workload` has been scheduled.
+             **/
+            core: number;
+            /**
+             * The time at which the `workload` will begin on the `core`.
+             **/
+            begin: number;
+            /**
+             * The number of timeslices for which this `workload` is newly scheduled.
+             **/
+            duration: number;
+            /**
+             * The workload which was renewed.
+             **/
+            workload: Array<PalletBrokerScheduleItem>;
+        }>;
+        /**
+         * Ownership of a Region has been transferred.
+         **/
+        Transferred: GenericPalletEvent<'Broker', 'Transferred', {
+            /**
+             * The Region which has been transferred.
+             **/
+            regionId: PalletBrokerRegionId;
+            /**
+             * The duration of the Region.
+             **/
+            duration: number;
+            /**
+             * The old owner of the Region.
+             **/
+            oldOwner: AccountId32;
+            /**
+             * The new owner of the Region.
+             **/
+            owner: AccountId32;
+        }>;
+        /**
+         * A Region has been split into two non-overlapping Regions.
+         **/
+        Partitioned: GenericPalletEvent<'Broker', 'Partitioned', {
+            /**
+             * The Region which was split.
+             **/
+            oldRegionId: PalletBrokerRegionId;
+            /**
+             * The new Regions into which it became.
+             **/
+            newRegionIds: [PalletBrokerRegionId, PalletBrokerRegionId];
+        }>;
+        /**
+         * A Region has been converted into two overlapping Regions each of lesser regularity.
+         **/
+        Interlaced: GenericPalletEvent<'Broker', 'Interlaced', {
+            /**
+             * The Region which was interlaced.
+             **/
+            oldRegionId: PalletBrokerRegionId;
+            /**
+             * The new Regions into which it became.
+             **/
+            newRegionIds: [PalletBrokerRegionId, PalletBrokerRegionId];
+        }>;
+        /**
+         * A Region has been assigned to a particular task.
+         **/
+        Assigned: GenericPalletEvent<'Broker', 'Assigned', {
+            /**
+             * The Region which was assigned.
+             **/
+            regionId: PalletBrokerRegionId;
+            /**
+             * The duration of the assignment.
+             **/
+            duration: number;
+            /**
+             * The task to which the Region was assigned.
+             **/
+            task: number;
+        }>;
+        /**
+         * A Region has been added to the Instantaneous Coretime Pool.
+         **/
+        Pooled: GenericPalletEvent<'Broker', 'Pooled', {
+            /**
+             * The Region which was added to the Instantaneous Coretime Pool.
+             **/
+            regionId: PalletBrokerRegionId;
+            /**
+             * The duration of the Region.
+             **/
+            duration: number;
+        }>;
+        /**
+         * A new number of cores has been requested.
+         **/
+        CoreCountRequested: GenericPalletEvent<'Broker', 'CoreCountRequested', {
+            /**
+             * The number of cores requested.
+             **/
+            coreCount: number;
+        }>;
+        /**
+         * The number of cores available for scheduling has changed.
+         **/
+        CoreCountChanged: GenericPalletEvent<'Broker', 'CoreCountChanged', {
+            /**
+             * The new number of cores available for scheduling.
+             **/
+            coreCount: number;
+        }>;
+        /**
+         * There is a new reservation for a workload.
+         **/
+        ReservationMade: GenericPalletEvent<'Broker', 'ReservationMade', {
+            /**
+             * The index of the reservation.
+             **/
+            index: number;
+            /**
+             * The workload of the reservation.
+             **/
+            workload: Array<PalletBrokerScheduleItem>;
+        }>;
+        /**
+         * A reservation for a workload has been cancelled.
+         **/
+        ReservationCancelled: GenericPalletEvent<'Broker', 'ReservationCancelled', {
+            /**
+             * The index of the reservation which was cancelled.
+             **/
+            index: number;
+            /**
+             * The workload of the now cancelled reservation.
+             **/
+            workload: Array<PalletBrokerScheduleItem>;
+        }>;
+        /**
+         * A new sale has been initialized.
+         **/
+        SaleInitialized: GenericPalletEvent<'Broker', 'SaleInitialized', {
+            /**
+             * The local block number at which the sale will/did start.
+             **/
+            saleStart: number;
+            /**
+             * The length in blocks of the Leadin Period (where the price is decreasing).
+             **/
+            leadinLength: number;
+            /**
+             * The price of Bulk Coretime at the beginning of the Leadin Period.
+             **/
+            startPrice: bigint;
+            /**
+             * The price of Bulk Coretime after the Leadin Period.
+             **/
+            regularPrice: bigint;
+            /**
+             * The first timeslice of the Regions which are being sold in this sale.
+             **/
+            regionBegin: number;
+            /**
+             * The timeslice on which the Regions which are being sold in the sale terminate.
+             * (i.e. One after the last timeslice which the Regions control.)
+             **/
+            regionEnd: number;
+            /**
+             * The number of cores we want to sell, ideally. Selling this amount would result in
+             * no change to the price for the next sale.
+             **/
+            idealCoresSold: number;
+            /**
+             * Number of cores which are/have been offered for sale.
+             **/
+            coresOffered: number;
+        }>;
+        /**
+         * A new lease has been created.
+         **/
+        Leased: GenericPalletEvent<'Broker', 'Leased', {
+            /**
+             * The task to which a core will be assigned.
+             **/
+            task: number;
+            /**
+             * The timeslice contained in the sale period after which this lease will
+             * self-terminate (and therefore the earliest timeslice at which the lease may no
+             * longer apply).
+             **/
+            until: number;
+        }>;
+        /**
+         * A lease is about to end.
+         **/
+        LeaseEnding: GenericPalletEvent<'Broker', 'LeaseEnding', {
+            /**
+             * The task to which a core was assigned.
+             **/
+            task: number;
+            /**
+             * The timeslice at which the task will no longer be scheduled.
+             **/
+            when: number;
+        }>;
+        /**
+         * The sale rotation has been started and a new sale is imminent.
+         **/
+        SalesStarted: GenericPalletEvent<'Broker', 'SalesStarted', {
+            /**
+             * The nominal price of an Region of Bulk Coretime.
+             **/
+            price: bigint;
+            /**
+             * The maximum number of cores which this pallet will attempt to assign.
+             **/
+            coreCount: number;
+        }>;
+        /**
+         * The act of claiming revenue has begun.
+         **/
+        RevenueClaimBegun: GenericPalletEvent<'Broker', 'RevenueClaimBegun', {
+            /**
+             * The region to be claimed for.
+             **/
+            region: PalletBrokerRegionId;
+            /**
+             * The maximum number of timeslices which should be searched for claimed.
+             **/
+            maxTimeslices: number;
+        }>;
+        /**
+         * A particular timeslice has a non-zero claim.
+         **/
+        RevenueClaimItem: GenericPalletEvent<'Broker', 'RevenueClaimItem', {
+            /**
+             * The timeslice whose claim is being processed.
+             **/
+            when: number;
+            /**
+             * The amount which was claimed at this timeslice.
+             **/
+            amount: bigint;
+        }>;
+        /**
+         * A revenue claim has (possibly only in part) been paid.
+         **/
+        RevenueClaimPaid: GenericPalletEvent<'Broker', 'RevenueClaimPaid', {
+            /**
+             * The account to whom revenue has been paid.
+             **/
+            who: AccountId32;
+            /**
+             * The total amount of revenue claimed and paid.
+             **/
+            amount: bigint;
+            /**
+             * The next region which should be claimed for the continuation of this contribution.
+             **/
+            next?: PalletBrokerRegionId | undefined;
+        }>;
+        /**
+         * Some Instantaneous Coretime Pool credit has been purchased.
+         **/
+        CreditPurchased: GenericPalletEvent<'Broker', 'CreditPurchased', {
+            /**
+             * The account which purchased the credit.
+             **/
+            who: AccountId32;
+            /**
+             * The Relay-chain account to which the credit will be made.
+             **/
+            beneficiary: AccountId32;
+            /**
+             * The amount of credit purchased.
+             **/
+            amount: bigint;
+        }>;
+        /**
+         * A Region has been dropped due to being out of date.
+         **/
+        RegionDropped: GenericPalletEvent<'Broker', 'RegionDropped', {
+            /**
+             * The Region which no longer exists.
+             **/
+            regionId: PalletBrokerRegionId;
+            /**
+             * The duration of the Region.
+             **/
+            duration: number;
+        }>;
+        /**
+         * Some historical Instantaneous Core Pool contribution record has been dropped.
+         **/
+        ContributionDropped: GenericPalletEvent<'Broker', 'ContributionDropped', {
+            /**
+             * The Region whose contribution is no longer exists.
+             **/
+            regionId: PalletBrokerRegionId;
+        }>;
+        /**
+         * Some historical Instantaneous Core Pool payment record has been initialized.
+         **/
+        HistoryInitialized: GenericPalletEvent<'Broker', 'HistoryInitialized', {
+            /**
+             * The timeslice whose history has been initialized.
+             **/
+            when: number;
+            /**
+             * The amount of privately contributed Coretime to the Instantaneous Coretime Pool.
+             **/
+            privatePoolSize: number;
+            /**
+             * The amount of Coretime contributed to the Instantaneous Coretime Pool by the
+             * Polkadot System.
+             **/
+            systemPoolSize: number;
+        }>;
+        /**
+         * Some historical Instantaneous Core Pool payment record has been dropped.
+         **/
+        HistoryDropped: GenericPalletEvent<'Broker', 'HistoryDropped', {
+            /**
+             * The timeslice whose history is no longer available.
+             **/
+            when: number;
+            /**
+             * The amount of revenue the system has taken.
+             **/
+            revenue: bigint;
+        }>;
+        /**
+         * Some historical Instantaneous Core Pool payment record has been ignored because the
+         * timeslice was already known. Governance may need to intervene.
+         **/
+        HistoryIgnored: GenericPalletEvent<'Broker', 'HistoryIgnored', {
+            /**
+             * The timeslice whose history is was ignored.
+             **/
+            when: number;
+            /**
+             * The amount of revenue which was ignored.
+             **/
+            revenue: bigint;
+        }>;
+        /**
+         * Some historical Instantaneous Core Pool Revenue is ready for payout claims.
+         **/
+        ClaimsReady: GenericPalletEvent<'Broker', 'ClaimsReady', {
+            /**
+             * The timeslice whose history is available.
+             **/
+            when: number;
+            /**
+             * The amount of revenue the Polkadot System has already taken.
+             **/
+            systemPayout: bigint;
+            /**
+             * The total amount of revenue remaining to be claimed.
+             **/
+            privatePayout: bigint;
+        }>;
+        /**
+         * A Core has been assigned to one or more tasks and/or the Pool on the Relay-chain.
+         **/
+        CoreAssigned: GenericPalletEvent<'Broker', 'CoreAssigned', {
+            /**
+             * The index of the Core which has been assigned.
+             **/
+            core: number;
+            /**
+             * The Relay-chain block at which this assignment should take effect.
+             **/
+            when: number;
+            /**
+             * The workload to be done on the Core.
+             **/
+            assignment: Array<[PalletBrokerCoretimeInterfaceCoreAssignment, number]>;
+        }>;
+        /**
+         * Some historical Instantaneous Core Pool payment record has been dropped.
+         **/
+        AllowedRenewalDropped: GenericPalletEvent<'Broker', 'AllowedRenewalDropped', {
+            /**
+             * The timeslice whose renewal is no longer available.
+             **/
+            when: number;
+            /**
+             * The core whose workload is no longer available to be renewed for `when`.
+             **/
+            core: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+}