import type { AccountId32, Bytes, DispatchError, FixedBytes, FixedU128, FixedU64, H160, H256, Perbill, Permill, Perquintill, Result } from '@dedot/codecs';
import type { GenericChainEvents, GenericPalletEvent } from '@dedot/types';
import type { FrameSupportDispatchPostDispatchInfo, FrameSupportMessagesProcessMessageError, FrameSupportPreimagesBounded, FrameSupportTokensFungibleUnionOfNativeOrWithId, FrameSupportTokensMiscBalanceStatus, FrameSystemDispatchEventInfo, KitchensinkRuntimeOriginCaller, KitchensinkRuntimeProxyType, KitchensinkRuntimeRuntimeParametersKey, KitchensinkRuntimeRuntimeParametersValue, PalletAllianceCid, PalletAllianceUnscrupulousItem, PalletBrokerCoretimeInterfaceCoreAssignment, PalletBrokerRegionId, PalletBrokerScheduleItem, PalletContractsOrigin, PalletConvictionVotingTally, PalletConvictionVotingVoteAccountVote, PalletCoreFellowshipParamsType, PalletCoreFellowshipWish, PalletDemocracyMetadataOwner, PalletDemocracyVoteAccountVote, PalletDemocracyVoteThreshold, PalletElectionProviderMultiPhaseElectionCompute, PalletElectionProviderMultiPhasePhase, PalletImOnlineSr25519AppSr25519Public, PalletMultisigTimepoint, PalletNftsAttributeNamespace, PalletNftsPalletAttributes, PalletNftsPriceWithDirection, PalletNominationPoolsClaimPermission, PalletNominationPoolsCommissionChangeRate, PalletNominationPoolsCommissionClaimPermission, PalletNominationPoolsPoolState, PalletProxyDepositKind, PalletRankedCollectiveTally, PalletRankedCollectiveVoteRecord, PalletSafeModeExitReason, PalletSocietyGroupParams, PalletStakingForcing, PalletStakingRewardDestination, PalletStakingValidatorPrefs, PalletStateTrieMigrationError, PalletStateTrieMigrationMigrationCompute, SpConsensusGrandpaAppPublic, SpNposElectionsElectionScore, SpRuntimeDispatchErrorWithPostInfo, SpStatementStoreStatement, SpWeightsWeightV2Weight } from './types.js';
export interface ChainEvents extends GenericChainEvents {
    /**
     * Pallet `System`'s events
     **/
    system: {
        /**
         * An extrinsic completed successfully.
         **/
        ExtrinsicSuccess: GenericPalletEvent<'System', 'ExtrinsicSuccess', {
            dispatchInfo: FrameSystemDispatchEventInfo;
        }>;
        /**
         * An extrinsic failed.
         **/
        ExtrinsicFailed: GenericPalletEvent<'System', 'ExtrinsicFailed', {
            dispatchError: DispatchError;
            dispatchInfo: FrameSystemDispatchEventInfo;
        }>;
        /**
         * `: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;
        }>;
        /**
         * An upgrade was authorized.
         **/
        UpgradeAuthorized: GenericPalletEvent<'System', 'UpgradeAuthorized', {
            codeHash: H256;
            checkVersion: boolean;
        }>;
        /**
         * An invalid authorized upgrade was rejected while trying to apply it.
         **/
        RejectedInvalidAuthorizedUpgrade: GenericPalletEvent<'System', 'RejectedInvalidAuthorizedUpgrade', {
            codeHash: H256;
            error: DispatchError;
        }>;
        /**
         * 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>;
        }>;
        /**
         * Main call was dispatched.
         **/
        IfElseMainSuccess: GenericPalletEvent<'Utility', 'IfElseMainSuccess', null>;
        /**
         * The fallback call was dispatched.
         **/
        IfElseFallbackCalled: GenericPalletEvent<'Utility', 'IfElseFallbackCalled', {
            mainError: 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;
        }>;
        /**
         * A deposit to reserve an index has been poked/reconsidered.
         **/
        DepositPoked: GenericPalletEvent<'Indices', 'DepositPoked', {
            who: AccountId32;
            index: number;
            oldDeposit: bigint;
            newDeposit: bigint;
        }>;
        /**
         * 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;
        }>;
        /**
         * The `TotalIssuance` was forcefully changed.
         **/
        TotalIssuanceForced: GenericPalletEvent<'Balances', 'TotalIssuanceForced', {
            old: bigint;
            new: 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 `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: FrameSupportTokensFungibleUnionOfNativeOrWithId;
        }>;
        /**
         * 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 submitted in the signed phase by a miner with the `AccountId`.
         * Otherwise, the solution was stored either during the unsigned phase or by
         * `T::ForceOrigin`. The `bool` is `true` when a previous solution was ejected to make
         * room for this one.
         **/
        SolutionStored: 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 to this destination.
         **/
        Rewarded: GenericPalletEvent<'Staking', 'Rewarded', {
            stash: AccountId32;
            dest: PalletStakingRewardDestination;
            amount: bigint;
        }>;
        /**
         * A staker (validator or nominator) has been slashed by the given amount.
         **/
        Slashed: GenericPalletEvent<'Staking', 'Slashed', {
            staker: AccountId32;
            amount: bigint;
        }>;
        /**
         * A slash for the given validator, for the given percentage of their stake, at the given
         * era as been reported.
         **/
        SlashReported: GenericPalletEvent<'Staking', 'SlashReported', {
            validator: AccountId32;
            fraction: Perbill;
            slashEra: number;
        }>;
        /**
         * An old slashing report from a prior era was discarded because it could
         * not be processed.
         **/
        OldSlashingReportDiscarded: GenericPalletEvent<'Staking', 'OldSlashingReportDiscarded', {
            sessionIndex: number;
        }>;
        /**
         * A new set of stakers was elected.
         **/
        StakersElected: GenericPalletEvent<'Staking', 'StakersElected', null>;
        /**
         * An account has bonded this amount. \[stash, amount\]
         *
         * NOTE: This event is only emitted when funds are bonded via a dispatchable. Notably,
         * it will not be emitted for staking rewards when they are added to stake.
         **/
        Bonded: GenericPalletEvent<'Staking', 'Bonded', {
            stash: AccountId32;
            amount: bigint;
        }>;
        /**
         * An account has unbonded this amount.
         **/
        Unbonded: GenericPalletEvent<'Staking', 'Unbonded', {
            stash: AccountId32;
            amount: bigint;
        }>;
        /**
         * An account has called `withdraw_unbonded` and removed unbonding chunks worth `Balance`
         * from the unlocking queue.
         **/
        Withdrawn: GenericPalletEvent<'Staking', 'Withdrawn', {
            stash: AccountId32;
            amount: bigint;
        }>;
        /**
         * A nominator has been kicked from a validator.
         **/
        Kicked: GenericPalletEvent<'Staking', 'Kicked', {
            nominator: AccountId32;
            stash: AccountId32;
        }>;
        /**
         * The election failed. No new era is planned.
         **/
        StakingElectionFailed: GenericPalletEvent<'Staking', 'StakingElectionFailed', null>;
        /**
         * An account has stopped participating as either a validator or nominator.
         **/
        Chilled: GenericPalletEvent<'Staking', 'Chilled', {
            stash: AccountId32;
        }>;
        /**
         * A Page of stakers rewards are getting paid. `next` is `None` if all pages are claimed.
         **/
        PayoutStarted: GenericPalletEvent<'Staking', 'PayoutStarted', {
            eraIndex: number;
            validatorStash: AccountId32;
            page: number;
            next?: number | undefined;
        }>;
        /**
         * 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;
        }>;
        /**
         * Report of a controller batch deprecation.
         **/
        ControllerBatchDeprecated: GenericPalletEvent<'Staking', 'ControllerBatchDeprecated', {
            failures: number;
        }>;
        /**
         * Staking balance migrated from locks to holds, with any balance that could not be held
         * is force withdrawn.
         **/
        CurrencyMigrated: GenericPalletEvent<'Staking', 'CurrencyMigrated', {
            stash: AccountId32;
            forceWithdraw: bigint;
        }>;
        /**
         * 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;
        }>;
        /**
         * Validator has been disabled.
         **/
        ValidatorDisabled: GenericPalletEvent<'Session', 'ValidatorDisabled', {
            validator: AccountId32;
        }>;
        /**
         * Validator has been re-enabled.
         **/
        ValidatorReenabled: GenericPalletEvent<'Session', 'ValidatorReenabled', {
            validator: AccountId32;
        }>;
        /**
         * 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 seconded 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;
        }>;
        /**
         * A proposal was killed.
         **/
        Killed: GenericPalletEvent<'Council', 'Killed', {
            proposalHash: H256;
        }>;
        /**
         * Some cost for storing a proposal was burned.
         **/
        ProposalCostBurned: GenericPalletEvent<'Council', 'ProposalCostBurned', {
            proposalHash: H256;
            who: AccountId32;
        }>;
        /**
         * Some cost for storing a proposal was released.
         **/
        ProposalCostReleased: GenericPalletEvent<'Council', 'ProposalCostReleased', {
            proposalHash: H256;
            who: AccountId32;
        }>;
        /**
         * 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;
        }>;
        /**
         * A proposal was killed.
         **/
        Killed: GenericPalletEvent<'TechnicalCommittee', 'Killed', {
            proposalHash: H256;
        }>;
        /**
         * Some cost for storing a proposal was burned.
         **/
        ProposalCostBurned: GenericPalletEvent<'TechnicalCommittee', 'ProposalCostBurned', {
            proposalHash: H256;
            who: AccountId32;
        }>;
        /**
         * Some cost for storing a proposal was released.
         **/
        ProposalCostReleased: GenericPalletEvent<'TechnicalCommittee', 'ProposalCostReleased', {
            proposalHash: H256;
            who: AccountId32;
        }>;
        /**
         * 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 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: {
        /**
         * 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;
        }>;
        /**
         * Some of our funds have been burnt.
         **/
        Burnt: GenericPalletEvent<'Treasury', 'Burnt', {
            burntFunds: bigint;
        }>;
        /**
         * Spending has finished; this is the amount that rolls over until next spend.
         **/
        Rollover: GenericPalletEvent<'Treasury', 'Rollover', {
            rolloverBalance: bigint;
        }>;
        /**
         * Some funds have been deposited.
         **/
        Deposit: GenericPalletEvent<'Treasury', 'Deposit', {
            value: bigint;
        }>;
        /**
         * A new spend proposal has been approved.
         **/
        SpendApproved: GenericPalletEvent<'Treasury', 'SpendApproved', {
            proposalIndex: number;
            amount: bigint;
            beneficiary: AccountId32;
        }>;
        /**
         * The inactive funds of the pallet have been updated.
         **/
        UpdatedInactive: GenericPalletEvent<'Treasury', 'UpdatedInactive', {
            reactivated: bigint;
            deactivated: bigint;
        }>;
        /**
         * A new asset spend proposal has been approved.
         **/
        AssetSpendApproved: GenericPalletEvent<'Treasury', 'AssetSpendApproved', {
            index: number;
            assetKind: FrameSupportTokensFungibleUnionOfNativeOrWithId;
            amount: bigint;
            beneficiary: AccountId32;
            validFrom: number;
            expireAt: number;
        }>;
        /**
         * An approved spend was voided.
         **/
        AssetSpendVoided: GenericPalletEvent<'Treasury', 'AssetSpendVoided', {
            index: number;
        }>;
        /**
         * A payment happened.
         **/
        Paid: GenericPalletEvent<'Treasury', 'Paid', {
            index: number;
            paymentId: [];
        }>;
        /**
         * A payment failed and can be retried.
         **/
        PaymentFailed: GenericPalletEvent<'Treasury', 'PaymentFailed', {
            index: number;
            paymentId: [];
        }>;
        /**
         * A spend was processed and removed from the storage. It might have been successfully
         * paid or it may have expired.
         **/
        SpendProcessed: GenericPalletEvent<'Treasury', 'SpendProcessed', {
            index: number;
        }>;
        /**
         * Generic pallet event
         **/
        [prop: string]: GenericPalletEvent;
    };
    /**
     * Pallet `AssetRate`'s events
     **/
    assetRate: {
        AssetRateCreated: GenericPalletEvent<'AssetRate', 'AssetRateCreated', {
            assetKind: FrameSupportTokensFungibleUnionOfNativeOrWithId;
            rate: FixedU128;
        }>;
        AssetRateRemoved: GenericPalletEvent<'AssetRate', 'AssetRateRemoved', {
            assetKind: FrameSupportTokensFungibleUnionOfNativeOrWithId;
        }>;
        AssetRateUpdated: GenericPalletEvent<'AssetRate', 'AssetRateUpdated', {
            assetKind: FrameSupportTokensFungibleUnionOfNativeOrWithId;
            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 call just took place.
         **/
        Sudid: GenericPalletEvent<'Sudo', 'Sudid', {
            /**
             * The result of the call made by the sudo user.
             **/
            sudoResult: Result<[], DispatchError>;
        }>;
        /**
         * The sudo key has been updated.
         **/
        KeyChanged: GenericPalletEvent<'Sudo', 'KeyChanged', {
            /**
             * The old sudo key (if one was previously set).
             **/
            old?: AccountId32 | undefined;
            /**
             * The new sudo key (if one was set).
             **/
            new: AccountId32;
        }>;
        /**
         * The key was permanently removed.
         **/
        KeyRemoved: GenericPalletEvent<'Sudo', 'KeyRemoved', null>;
        /**
         * A [sudo_as](Pallet::sudo_as) call just took place.
         **/
        SudoAsDone: GenericPalletEvent<'Sudo', 'SudoAsDone', {
            /**
             * The result of the call made by the sudo user.
             **/
            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, []]>;
        }>;
        /**
         * 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;
        }>;
        /**
         * An account's sub-identities were set (in bulk).
         **/
        SubIdentitiesSet: GenericPalletEvent<'Identity', 'SubIdentitiesSet', {
            main: AccountId32;
            numberOfSubs: number;
            newDeposit: bigint;
        }>;
        /**
         * A given sub-account's associated name was changed by its super-identity.
         **/
        SubIdentityRenamed: GenericPalletEvent<'Identity', 'SubIdentityRenamed', {
            sub: AccountId32;
            main: AccountId32;
        }>;
        /**
         * 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;
        }>;
        /**
         * A username authority was added.
         **/
        AuthorityAdded: GenericPalletEvent<'Identity', 'AuthorityAdded', {
            authority: AccountId32;
        }>;
        /**
         * A username authority was removed.
         **/
        AuthorityRemoved: GenericPalletEvent<'Identity', 'AuthorityRemoved', {
            authority: AccountId32;
        }>;
        /**
         * A username was set for `who`.
         **/
        UsernameSet: GenericPalletEvent<'Identity', 'UsernameSet', {
            who: AccountId32;
            username: Bytes;
        }>;
        /**
         * A username was queued, but `who` must accept it prior to `expiration`.
         **/
        UsernameQueued: GenericPalletEvent<'Identity', 'UsernameQueued', {
            who: AccountId32;
            username: Bytes;
            expiration: number;
        }>;
        /**
         * A queued username passed its expiration without being claimed and was removed.
         **/
        PreapprovalExpired: GenericPalletEvent<'Identity', 'PreapprovalExpired', {
            whose: AccountId32;
        }>;
        /**
         * A username was set as a primary and can be looked up from `who`.
         **/
        PrimaryUsernameSet: GenericPalletEvent<'Identity', 'PrimaryUsernameSet', {
            who: AccountId32;
            username: Bytes;
        }>;
        /**
         * A dangling username (as in, a username corresponding to an account that has removed its
         * identity) has been removed.
         **/
        DanglingUsernameRemoved: GenericPalletEvent<'Identity', 'DanglingUsernameRemoved', {
            who: AccountId32;
            username: Bytes;
        }>;
        /**
         * A username has been unbound.
         **/
        UsernameUnbound: GenericPalletEvent<'Identity', 'UsernameUnbound', {
            username: Bytes;
        }>;
        /**
         * A username has been removed.
         **/
        UsernameRemoved: GenericPalletEvent<'Identity', 'UsernameRemoved', {
            username: Bytes;
        }>;
        /**
         * A username has been killed.
         **/
        UsernameKilled: GenericPalletEvent<'Identity', 'UsernameKilled', {
            username: Bytes;
        }>;
        /**
         * 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>;
        }>;
        /**
         * Set a retry configuration for some task.
         **/
        RetrySet: GenericPalletEvent<'Scheduler', 'RetrySet', {
            task: [number, number];
            id?: FixedBytes<32> | undefined;
            period: number;
            retries: number;
        }>;
        /**
         * Cancel a retry configuration for some task.
         **/
        RetryCancelled: GenericPalletEvent<'Scheduler', 'RetryCancelled', {
            task: [number, number];
            id?: FixedBytes<32> | undefined;
        }>;
        /**
         * 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 was unable to be retried since the agenda is full at that block or there
         * was not enough weight to reschedule it.
         **/
        RetryFailed: GenericPalletEvent<'Scheduler', 'RetryFailed', {
            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;
        }>;
        /**
         * Agenda is incomplete from `when`.
         **/
        AgendaIncomplete: GenericPalletEvent<'Scheduler', 'AgendaIncomplete', {
            when: number;
        }>;
        /**
         * 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;
        }>;
        /**
         * The block length limit has been updated.
         **/
        BlockLengthLimitSet: GenericPalletEvent<'Glutton', 'BlockLengthLimitSet', {
            /**
             * The block length limit.
             **/
            blockLength: 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;
        }>;
        /**
         * A deposit stored for proxies or announcements was poked / updated.
         **/
        DepositPoked: GenericPalletEvent<'Proxy', 'DepositPoked', {
            who: AccountId32;
            kind: PalletProxyDepositKind;
            oldDeposit: bigint;
            newDeposit: bigint;
        }>;
        /**
         * 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>;
        }>;
        /**
         * The deposit for a multisig operation has been updated/poked.
         **/
        DepositPoked: GenericPalletEvent<'Multisig', 'DepositPoked', {
            who: AccountId32;
            callHash: FixedBytes<32>;
            oldDeposit: bigint;
            newDeposit: bigint;
        }>;
        /**
         * Generic pallet event
         **/
        [prop: string]: GenericPalletEvent;
    };
    /**
     * Pallet `Bounties`'s events
     **/
    bounties: {
        /**
         * New bounty proposal.
         **/
        BountyProposed: GenericPalletEvent<'Bounties', 'BountyProposed', {
            index: number;
        }>;
        /**
         * A bounty proposal was rejected; funds were slashed.
         **/
        BountyRejected: GenericPalletEvent<'Bounties', 'BountyRejected', {
            index: number;
            bond: bigint;
        }>;
        /**
         * A bounty proposal is funded and became active.
         **/
        BountyBecameActive: GenericPalletEvent<'Bounties', 'BountyBecameActive', {
            index: number;
        }>;
        /**
         * A bounty is awarded to a beneficiary.
         **/
        BountyAwarded: GenericPalletEvent<'Bounties', 'BountyAwarded', {
            index: number;
            beneficiary: AccountId32;
        }>;
        /**
         * A bounty is claimed by beneficiary.
         **/
        BountyClaimed: GenericPalletEvent<'Bounties', 'BountyClaimed', {
            index: number;
            payout: bigint;
            beneficiary: AccountId32;
        }>;
        /**
         * A bounty is cancelled.
         **/
        BountyCanceled: GenericPalletEvent<'Bounties', 'BountyCanceled', {
            index: number;
        }>;
        /**
         * A bounty expiry is extended.
         **/
        BountyExtended: GenericPalletEvent<'Bounties', 'BountyExtended', {
            index: number;
        }>;
        /**
         * A bounty is approved.
         **/
        BountyApproved: GenericPalletEvent<'Bounties', 'BountyApproved', {
            index: number;
        }>;
        /**
         * A bounty curator is proposed.
         **/
        CuratorProposed: GenericPalletEvent<'Bounties', 'CuratorProposed', {
            bountyId: number;
            curator: AccountId32;
        }>;
        /**
         * A bounty curator is unassigned.
         **/
        CuratorUnassigned: GenericPalletEvent<'Bounties', 'CuratorUnassigned', {
            bountyId: number;
        }>;
        /**
         * A bounty curator is accepted.
         **/
        CuratorAccepted: GenericPalletEvent<'Bounties', 'CuratorAccepted', {
            bountyId: number;
            curator: AccountId32;
        }>;
        /**
         * Generic pallet event
         **/
        [prop: string]: GenericPalletEvent;
    };
    /**
     * Pallet `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;
        }>;
        /**
         * Some assets were deposited (e.g. for transaction fees).
         **/
        Deposited: GenericPalletEvent<'Assets', 'Deposited', {
            assetId: number;
            who: AccountId32;
            amount: bigint;
        }>;
        /**
         * Some assets were withdrawn from the account (e.g. for transaction fees).
         **/
        Withdrawn: GenericPalletEvent<'Assets', 'Withdrawn', {
            assetId: number;
            who: AccountId32;
            amount: bigint;
        }>;
        /**
         * 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;
        }>;
        /**
         * Some assets were deposited (e.g. for transaction fees).
         **/
        Deposited: GenericPalletEvent<'PoolAssets', 'Deposited', {
            assetId: number;
            who: AccountId32;
            amount: bigint;
        }>;
        /**
         * Some assets were withdrawn from the account (e.g. for transaction fees).
         **/
        Withdrawn: GenericPalletEvent<'PoolAssets', 'Withdrawn', {
            assetId: number;
            who: AccountId32;
            amount: bigint;
        }>;
        /**
         * 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 transferred.
         **/
        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;
        }>;
        /**
         * A member swapped their account.
         **/
        Swapped: GenericPalletEvent<'Salary', 'Swapped', {
            who: AccountId32;
            newWho: AccountId32;
        }>;
        /**
         * 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;
        }>;
        /**
         * A member had its AccountId swapped.
         **/
        Swapped: GenericPalletEvent<'CoreFellowship', 'Swapped', {
            who: AccountId32;
            newWho: AccountId32;
        }>;
        /**
         * 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 slashed.
         **/
        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 `RootTesting`'s events
     **/
    rootTesting: {
        /**
         * Event dispatched when the trigger_defensive extrinsic is called.
         **/
        DefensiveTestCall: GenericPalletEvent<'RootTesting', 'DefensiveTestCall', undefined>;
        /**
         * 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>;
        /**
         * An account has voted
         **/
        Voted: GenericPalletEvent<'ConvictionVoting', 'Voted', {
            who: AccountId32;
            vote: PalletConvictionVotingVoteAccountVote;
        }>;
        /**
         * A vote has been removed
         **/
        VoteRemoved: GenericPalletEvent<'ConvictionVoting', 'VoteRemoved', {
            who: AccountId32;
            vote: PalletConvictionVotingVoteAccountVote;
        }>;
        /**
         * The lockup period of a conviction vote expired, and the funds have been unlocked.
         **/
        VoteUnlocked: GenericPalletEvent<'ConvictionVoting', 'VoteUnlocked', {
            who: AccountId32;
            class: number;
        }>;
        /**
         * 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;
        }>;
        /**
         * A proposal was killed.
         **/
        Killed: GenericPalletEvent<'AllianceMotion', 'Killed', {
            proposalHash: H256;
        }>;
        /**
         * Some cost for storing a proposal was burned.
         **/
        ProposalCostBurned: GenericPalletEvent<'AllianceMotion', 'ProposalCostBurned', {
            proposalHash: H256;
            who: AccountId32;
        }>;
        /**
         * Some cost for storing a proposal was released.
         **/
        ProposalCostReleased: GenericPalletEvent<'AllianceMotion', 'ProposalCostReleased', {
            proposalHash: H256;
            who: AccountId32;
        }>;
        /**
         * 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).
         * Any funds that are still delegated (i.e. dangling delegation) are released and are
         * represented by `released_balance`.
         **/
        MemberRemoved: GenericPalletEvent<'NominationPools', 'MemberRemoved', {
            poolId: number;
            member: AccountId32;
            releasedBalance: bigint;
        }>;
        /**
         * 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 claim permission has been updated.
         **/
        PoolCommissionClaimPermissionUpdated: GenericPalletEvent<'NominationPools', 'PoolCommissionClaimPermissionUpdated', {
            poolId: number;
            permission?: PalletNominationPoolsCommissionClaimPermission | undefined;
        }>;
        /**
         * Pool commission has been claimed.
         **/
        PoolCommissionClaimed: GenericPalletEvent<'NominationPools', 'PoolCommissionClaimed', {
            poolId: number;
            commission: bigint;
        }>;
        /**
         * Topped up deficit in frozen ED of the reward pool.
         **/
        MinBalanceDeficitAdjusted: GenericPalletEvent<'NominationPools', 'MinBalanceDeficitAdjusted', {
            poolId: number;
            amount: bigint;
        }>;
        /**
         * Claimed excess frozen ED of af the reward pool.
         **/
        MinBalanceExcessAdjusted: GenericPalletEvent<'NominationPools', 'MinBalanceExcessAdjusted', {
            poolId: number;
            amount: bigint;
        }>;
        /**
         * A pool member's claim permission has been updated.
         **/
        MemberClaimPermissionUpdated: GenericPalletEvent<'NominationPools', 'MemberClaimPermissionUpdated', {
            member: AccountId32;
            permission: PalletNominationPoolsClaimPermission;
        }>;
        /**
         * A pool's metadata was updated.
         **/
        MetadataUpdated: GenericPalletEvent<'NominationPools', 'MetadataUpdated', {
            poolId: number;
            caller: AccountId32;
        }>;
        /**
         * A pool's nominating account (or the pool's root account) has nominated a validator set
         * on behalf of the pool.
         **/
        PoolNominationMade: GenericPalletEvent<'NominationPools', 'PoolNominationMade', {
            poolId: number;
            caller: AccountId32;
        }>;
        /**
         * The pool is chilled i.e. no longer nominating.
         **/
        PoolNominatorChilled: GenericPalletEvent<'NominationPools', 'PoolNominatorChilled', {
            poolId: number;
            caller: AccountId32;
        }>;
        /**
         * Global parameters regulating nomination pools have been updated.
         **/
        GlobalParamsUpdated: GenericPalletEvent<'NominationPools', 'GlobalParamsUpdated', {
            minJoinBond: bigint;
            minCreateBond: bigint;
            maxPools?: number | undefined;
            maxMembers?: number | undefined;
            maxMembersPerPool?: number | undefined;
            globalMaxCommission?: Perbill | undefined;
        }>;
        /**
         * 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 slashed.
         **/
        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;
        }>;
        /**
         * The member `who` had their `AccountId` changed to `new_who`.
         **/
        MemberExchanged: GenericPalletEvent<'RankedCollective', 'MemberExchanged', {
            who: AccountId32;
            newWho: AccountId32;
        }>;
        /**
         * Generic pallet event
         **/
        [prop: string]: GenericPalletEvent;
    };
    /**
     * Pallet `AssetConversion`'s events
     **/
    assetConversion: {
        /**
         * A successful call of the `CreatePool` 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: [FrameSupportTokensFungibleUnionOfNativeOrWithId, FrameSupportTokensFungibleUnionOfNativeOrWithId];
            /**
             * 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: [FrameSupportTokensFungibleUnionOfNativeOrWithId, FrameSupportTokensFungibleUnionOfNativeOrWithId];
            /**
             * 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: [FrameSupportTokensFungibleUnionOfNativeOrWithId, FrameSupportTokensFungibleUnionOfNativeOrWithId];
            /**
             * 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 amount of the first asset that was swapped.
             **/
            amountIn: bigint;
            /**
             * The amount of the second asset that was received.
             **/
            amountOut: bigint;
            /**
             * The route of asset IDs with amounts that the swap went through.
             * E.g. (A, amount_in) -> (Dot, amount_out) -> (B, amount_out)
             **/
            path: Array<[FrameSupportTokensFungibleUnionOfNativeOrWithId, bigint]>;
        }>;
        /**
         * Assets have been converted from one to another.
         **/
        SwapCreditExecuted: GenericPalletEvent<'AssetConversion', 'SwapCreditExecuted', {
            /**
             * The amount of the first asset that was swapped.
             **/
            amountIn: bigint;
            /**
             * The amount of the second asset that was received.
             **/
            amountOut: bigint;
            /**
             * The route of asset IDs with amounts that the swap went through.
             * E.g. (A, amount_in) -> (Dot, amount_out) -> (B, amount_out)
             **/
            path: Array<[FrameSupportTokensFungibleUnionOfNativeOrWithId, bigint]>;
        }>;
        /**
         * Pool has been touched in order to fulfill operational requirements.
         **/
        Touched: GenericPalletEvent<'AssetConversion', 'Touched', {
            /**
             * The ID of the pool.
             **/
            poolId: [FrameSupportTokensFungibleUnionOfNativeOrWithId, FrameSupportTokensFungibleUnionOfNativeOrWithId];
            /**
             * The account initiating the touch.
             **/
            who: AccountId32;
        }>;
        /**
         * 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', {
            /**
             * The `blake2_256` hash of the message.
             **/
            id: H256;
            /**
             * The queue of the message.
             **/
            origin: number;
            /**
             * The error that occurred.
             *
             * This error is pretty opaque. More fine-grained errors need to be emitted as events
             * by the `MessageProcessor`.
             **/
            error: FrameSupportMessagesProcessMessageError;
        }>;
        /**
         * Message is processed.
         **/
        Processed: GenericPalletEvent<'MessageQueue', 'Processed', {
            /**
             * The `blake2_256` hash of the message.
             **/
            id: H256;
            /**
             * The queue of the message.
             **/
            origin: number;
            /**
             * How much weight was used to process the message.
             **/
            weightUsed: SpWeightsWeightV2Weight;
            /**
             * Whether the message was processed.
             *
             * Note that this does not mean that the underlying `MessageProcessor` was internally
             * successful. It *solely* means that the MQ pallet will treat this as a success
             * condition and discard the message. Any internal error needs to be emitted as events
             * by the `MessageProcessor`.
             **/
            success: boolean;
        }>;
        /**
         * Message placed in overweight queue.
         **/
        OverweightEnqueued: GenericPalletEvent<'MessageQueue', 'OverweightEnqueued', {
            /**
             * The `blake2_256` hash of the message.
             **/
            id: FixedBytes<32>;
            /**
             * The queue of the message.
             **/
            origin: number;
            /**
             * The page of the message.
             **/
            pageIndex: number;
            /**
             * The index of the message within the page.
             **/
            messageIndex: number;
        }>;
        /**
         * This page was reaped.
         **/
        PageReaped: GenericPalletEvent<'MessageQueue', 'PageReaped', {
            /**
             * The queue of the page.
             **/
            origin: number;
            /**
             * The index of the page.
             **/
            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 `MultiBlockMigrations`'s events
     **/
    multiBlockMigrations: {
        /**
         * A Runtime upgrade started.
         *
         * Its end is indicated by `UpgradeCompleted` or `UpgradeFailed`.
         **/
        UpgradeStarted: GenericPalletEvent<'MultiBlockMigrations', 'UpgradeStarted', {
            /**
             * The number of migrations that this upgrade contains.
             *
             * This can be used to design a progress indicator in combination with counting the
             * `MigrationCompleted` and `MigrationSkipped` events.
             **/
            migrations: number;
        }>;
        /**
         * The current runtime upgrade completed.
         *
         * This implies that all of its migrations completed successfully as well.
         **/
        UpgradeCompleted: GenericPalletEvent<'MultiBlockMigrations', 'UpgradeCompleted', null>;
        /**
         * Runtime upgrade failed.
         *
         * This is very bad and will require governance intervention.
         **/
        UpgradeFailed: GenericPalletEvent<'MultiBlockMigrations', 'UpgradeFailed', null>;
        /**
         * A migration was skipped since it was already executed in the past.
         **/
        MigrationSkipped: GenericPalletEvent<'MultiBlockMigrations', 'MigrationSkipped', {
            /**
             * The index of the skipped migration within the [`Config::Migrations`] list.
             **/
            index: number;
        }>;
        /**
         * A migration progressed.
         **/
        MigrationAdvanced: GenericPalletEvent<'MultiBlockMigrations', 'MigrationAdvanced', {
            /**
             * The index of the migration within the [`Config::Migrations`] list.
             **/
            index: number;
            /**
             * The number of blocks that this migration took so far.
             **/
            took: number;
        }>;
        /**
         * A Migration completed.
         **/
        MigrationCompleted: GenericPalletEvent<'MultiBlockMigrations', 'MigrationCompleted', {
            /**
             * The index of the migration within the [`Config::Migrations`] list.
             **/
            index: number;
            /**
             * The number of blocks that this migration took so far.
             **/
            took: number;
        }>;
        /**
         * A Migration failed.
         *
         * This implies that the whole upgrade failed and governance intervention is required.
         **/
        MigrationFailed: GenericPalletEvent<'MultiBlockMigrations', 'MigrationFailed', {
            /**
             * The index of the migration within the [`Config::Migrations`] list.
             **/
            index: number;
            /**
             * The number of blocks that this migration took so far.
             **/
            took: number;
        }>;
        /**
         * The set of historical migrations has been cleared.
         **/
        HistoricCleared: GenericPalletEvent<'MultiBlockMigrations', 'HistoricCleared', {
            /**
             * Should be passed to `clear_historic` in a successive call.
             **/
            nextCursor?: Bytes | undefined;
        }>;
        /**
         * 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 | undefined;
            /**
             * The new owner of the Region.
             **/
            owner?: AccountId32 | undefined;
        }>;
        /**
         * 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;
        }>;
        /**
         * An assignment has been removed from the workplan.
         **/
        AssignmentRemoved: GenericPalletEvent<'Broker', 'AssignmentRemoved', {
            /**
             * The Region which was removed from the workplan.
             **/
            regionId: PalletBrokerRegionId;
        }>;
        /**
         * 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 relay block number at which the sale will/did start.
             **/
            saleStart: number;
            /**
             * The length in relay chain 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.
             **/
            endPrice: 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.
             **/
            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 has been removed.
         **/
        LeaseRemoved: GenericPalletEvent<'Broker', 'LeaseRemoved', {
            /**
             * The task to which a core was assigned.
             **/
            task: 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.
         **/
        PotentialRenewalDropped: GenericPalletEvent<'Broker', 'PotentialRenewalDropped', {
            /**
             * 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;
        }>;
        AutoRenewalEnabled: GenericPalletEvent<'Broker', 'AutoRenewalEnabled', {
            /**
             * The core for which the renewal was enabled.
             **/
            core: number;
            /**
             * The task for which the renewal was enabled.
             **/
            task: number;
        }>;
        AutoRenewalDisabled: GenericPalletEvent<'Broker', 'AutoRenewalDisabled', {
            /**
             * The core for which the renewal was disabled.
             **/
            core: number;
            /**
             * The task for which the renewal was disabled.
             **/
            task: number;
        }>;
        /**
         * Failed to auto-renew a core, likely due to the payer account not being sufficiently
         * funded.
         **/
        AutoRenewalFailed: GenericPalletEvent<'Broker', 'AutoRenewalFailed', {
            /**
             * The core for which the renewal failed.
             **/
            core: number;
            /**
             * The account which was supposed to pay for renewal.
             *
             * If `None` it indicates that we failed to get the sovereign account of a task.
             **/
            payer?: AccountId32 | undefined;
        }>;
        /**
         * The auto-renewal limit has been reached upon renewing cores.
         *
         * This should never happen, given that enable_auto_renew checks for this before enabling
         * auto-renewal.
         **/
        AutoRenewalLimitReached: GenericPalletEvent<'Broker', 'AutoRenewalLimitReached', null>;
        /**
         * Generic pallet event
         **/
        [prop: string]: GenericPalletEvent;
    };
    /**
     * Pallet `Parameters`'s events
     **/
    parameters: {
        /**
         * A Parameter was set.
         *
         * Is also emitted when the value was not changed.
         **/
        Updated: GenericPalletEvent<'Parameters', 'Updated', {
            /**
             * The key that was updated.
             **/
            key: KitchensinkRuntimeRuntimeParametersKey;
            /**
             * The old value before this call.
             **/
            oldValue?: KitchensinkRuntimeRuntimeParametersValue | undefined;
            /**
             * The new value after this call.
             **/
            newValue?: KitchensinkRuntimeRuntimeParametersValue | undefined;
        }>;
        /**
         * Generic pallet event
         **/
        [prop: string]: GenericPalletEvent;
    };
    /**
     * Pallet `SkipFeelessPayment`'s events
     **/
    skipFeelessPayment: {
        /**
         * A transaction fee was skipped.
         **/
        FeeSkipped: GenericPalletEvent<'SkipFeelessPayment', 'FeeSkipped', {
            origin: KitchensinkRuntimeOriginCaller;
        }>;
        /**
         * Generic pallet event
         **/
        [prop: string]: GenericPalletEvent;
    };
    /**
     * Pallet `AssetConversionMigration`'s events
     **/
    assetConversionMigration: {
        /**
         * Indicates that a pool has been migrated to the new account ID.
         **/
        MigratedToNewAccount: GenericPalletEvent<'AssetConversionMigration', 'MigratedToNewAccount', {
            /**
             * Pool's ID.
             **/
            poolId: [FrameSupportTokensFungibleUnionOfNativeOrWithId, FrameSupportTokensFungibleUnionOfNativeOrWithId];
            /**
             * Pool's prior account ID.
             **/
            priorAccount: AccountId32;
            /**
             * Pool's new account ID.
             **/
            newAccount: AccountId32;
        }>;
        /**
         * Generic pallet event
         **/
        [prop: string]: GenericPalletEvent;
    };
    /**
     * Pallet `Revive`'s events
     **/
    revive: {
        /**
         * A custom event emitted by the contract.
         **/
        ContractEmitted: GenericPalletEvent<'Revive', 'ContractEmitted', {
            /**
             * The contract that emitted the event.
             **/
            contract: H160;
            /**
             * Data supplied by the contract. Metadata generated during contract compilation
             * is needed to decode it.
             **/
            data: Bytes;
            /**
             * A list of topics used to index the event.
             * Number of topics is capped by [`limits::NUM_EVENT_TOPICS`].
             **/
            topics: Array<H256>;
        }>;
        /**
         * Generic pallet event
         **/
        [prop: string]: GenericPalletEvent;
    };
    /**
     * Pallet `DelegatedStaking`'s events
     **/
    delegatedStaking: {
        /**
         * Funds delegated by a delegator.
         **/
        Delegated: GenericPalletEvent<'DelegatedStaking', 'Delegated', {
            agent: AccountId32;
            delegator: AccountId32;
            amount: bigint;
        }>;
        /**
         * Funds released to a delegator.
         **/
        Released: GenericPalletEvent<'DelegatedStaking', 'Released', {
            agent: AccountId32;
            delegator: AccountId32;
            amount: bigint;
        }>;
        /**
         * Funds slashed from a delegator.
         **/
        Slashed: GenericPalletEvent<'DelegatedStaking', 'Slashed', {
            agent: AccountId32;
            delegator: AccountId32;
            amount: bigint;
        }>;
        /**
         * Unclaimed delegation funds migrated to delegator.
         **/
        MigratedDelegation: GenericPalletEvent<'DelegatedStaking', 'MigratedDelegation', {
            agent: AccountId32;
            delegator: AccountId32;
            amount: bigint;
        }>;
        /**
         * Generic pallet event
         **/
        [prop: string]: GenericPalletEvent;
    };
    /**
     * Pallet `AssetRewards`'s events
     **/
    assetRewards: {
        /**
         * An account staked some tokens in a pool.
         **/
        Staked: GenericPalletEvent<'AssetRewards', 'Staked', {
            /**
             * The account that staked assets.
             **/
            staker: AccountId32;
            /**
             * The pool.
             **/
            poolId: number;
            /**
             * The staked asset amount.
             **/
            amount: bigint;
        }>;
        /**
         * An account unstaked some tokens from a pool.
         **/
        Unstaked: GenericPalletEvent<'AssetRewards', 'Unstaked', {
            /**
             * The account that signed transaction.
             **/
            caller: AccountId32;
            /**
             * The account that unstaked assets.
             **/
            staker: AccountId32;
            /**
             * The pool.
             **/
            poolId: number;
            /**
             * The unstaked asset amount.
             **/
            amount: bigint;
        }>;
        /**
         * An account harvested some rewards.
         **/
        RewardsHarvested: GenericPalletEvent<'AssetRewards', 'RewardsHarvested', {
            /**
             * The account that signed transaction.
             **/
            caller: AccountId32;
            /**
             * The staker whos rewards were harvested.
             **/
            staker: AccountId32;
            /**
             * The pool.
             **/
            poolId: number;
            /**
             * The amount of harvested tokens.
             **/
            amount: bigint;
        }>;
        /**
         * A new reward pool was created.
         **/
        PoolCreated: GenericPalletEvent<'AssetRewards', 'PoolCreated', {
            /**
             * The account that created the pool.
             **/
            creator: AccountId32;
            /**
             * The unique ID for the new pool.
             **/
            poolId: number;
            /**
             * The staking asset.
             **/
            stakedAssetId: FrameSupportTokensFungibleUnionOfNativeOrWithId;
            /**
             * The reward asset.
             **/
            rewardAssetId: FrameSupportTokensFungibleUnionOfNativeOrWithId;
            /**
             * The initial reward rate per block.
             **/
            rewardRatePerBlock: bigint;
            /**
             * The block the pool will cease to accumulate rewards.
             **/
            expiryBlock: number;
            /**
             * The account allowed to modify the pool.
             **/
            admin: AccountId32;
        }>;
        /**
         * A pool reward rate was modified by the admin.
         **/
        PoolRewardRateModified: GenericPalletEvent<'AssetRewards', 'PoolRewardRateModified', {
            /**
             * The modified pool.
             **/
            poolId: number;
            /**
             * The new reward rate per block.
             **/
            newRewardRatePerBlock: bigint;
        }>;
        /**
         * A pool admin was modified.
         **/
        PoolAdminModified: GenericPalletEvent<'AssetRewards', 'PoolAdminModified', {
            /**
             * The modified pool.
             **/
            poolId: number;
            /**
             * The new admin.
             **/
            newAdmin: AccountId32;
        }>;
        /**
         * A pool expiry block was modified by the admin.
         **/
        PoolExpiryBlockModified: GenericPalletEvent<'AssetRewards', 'PoolExpiryBlockModified', {
            /**
             * The modified pool.
             **/
            poolId: number;
            /**
             * The new expiry block.
             **/
            newExpiryBlock: number;
        }>;
        /**
         * A pool information was cleared after it's completion.
         **/
        PoolCleanedUp: GenericPalletEvent<'AssetRewards', 'PoolCleanedUp', {
            /**
             * The cleared pool.
             **/
            poolId: number;
        }>;
        /**
         * Generic pallet event
         **/
        [prop: string]: GenericPalletEvent;
    };
    /**
     * Pallet `AssetsFreezer`'s events
     **/
    assetsFreezer: {
        Frozen: GenericPalletEvent<'AssetsFreezer', 'Frozen', {
            who: AccountId32;
            assetId: number;
            amount: bigint;
        }>;
        Thawed: GenericPalletEvent<'AssetsFreezer', 'Thawed', {
            who: AccountId32;
            assetId: number;
            amount: bigint;
        }>;
        /**
         * Generic pallet event
         **/
        [prop: string]: GenericPalletEvent;
    };
    /**
     * Pallet `MetaTx`'s events
     **/
    metaTx: {
        /**
         * A meta transaction has been dispatched.
         *
         * Contains the dispatch result of the meta transaction along with post-dispatch
         * information.
         **/
        Dispatched: GenericPalletEvent<'MetaTx', 'Dispatched', {
            result: Result<FrameSupportDispatchPostDispatchInfo, SpRuntimeDispatchErrorWithPostInfo>;
        }>;
        /**
         * Generic pallet event
         **/
        [prop: string]: GenericPalletEvent;
    };
}