@dedot/chaintypes 0.0.1-alpha.22

package/rococoAssetHub/events.d.ts

@@ -0,0 +1,2172 @@
+import type { GenericChainEvents, GenericPalletEvent } from '@dedot/types';
+import type { DispatchInfo, DispatchError, AccountId32, H256, FixedBytes, Result, Bytes, Permill } from '@dedot/codecs';
+import type { SpWeightsWeightV2Weight, FrameSupportTokensMiscBalanceStatus, StagingXcmV3MultilocationMultiLocation, StagingXcmV4TraitsOutcome, StagingXcmV4Location, StagingXcmV4Xcm, StagingXcmV4Response, XcmVersionedAssets, StagingXcmV4AssetAssets, XcmV3TraitsError, XcmVersionedLocation, CumulusPrimitivesCoreAggregateMessageOrigin, FrameSupportMessagesProcessMessageError, PalletMultisigTimepoint, AssetHubRococoRuntimeProxyType, PalletNftsAttributeNamespace, PalletNftsPriceWithDirection, PalletNftsPalletAttributes } from './types';
+export interface ChainEvents extends GenericChainEvents {
+    /**
+     * Pallet `System`'s events
+     **/
+    system: {
+        /**
+         * An extrinsic completed successfully.
+         **/
+        ExtrinsicSuccess: GenericPalletEvent<'System', 'ExtrinsicSuccess', {
+            dispatchInfo: DispatchInfo;
+        }>;
+        /**
+         * An extrinsic failed.
+         **/
+        ExtrinsicFailed: GenericPalletEvent<'System', 'ExtrinsicFailed', {
+            dispatchError: DispatchError;
+            dispatchInfo: DispatchInfo;
+        }>;
+        /**
+         * `:code` was updated.
+         **/
+        CodeUpdated: GenericPalletEvent<'System', 'CodeUpdated', null>;
+        /**
+         * A new account was created.
+         **/
+        NewAccount: GenericPalletEvent<'System', 'NewAccount', {
+            account: AccountId32;
+        }>;
+        /**
+         * An account was reaped.
+         **/
+        KilledAccount: GenericPalletEvent<'System', 'KilledAccount', {
+            account: AccountId32;
+        }>;
+        /**
+         * On on-chain remark happened.
+         **/
+        Remarked: GenericPalletEvent<'System', 'Remarked', {
+            sender: AccountId32;
+            hash: H256;
+        }>;
+        /**
+         * An upgrade was authorized.
+         **/
+        UpgradeAuthorized: GenericPalletEvent<'System', 'UpgradeAuthorized', {
+            codeHash: H256;
+            checkVersion: boolean;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `ParachainSystem`'s events
+     **/
+    parachainSystem: {
+        /**
+         * The validation function has been scheduled to apply.
+         **/
+        ValidationFunctionStored: GenericPalletEvent<'ParachainSystem', 'ValidationFunctionStored', null>;
+        /**
+         * The validation function was applied as of the contained relay chain block number.
+         **/
+        ValidationFunctionApplied: GenericPalletEvent<'ParachainSystem', 'ValidationFunctionApplied', {
+            relayChainBlockNum: number;
+        }>;
+        /**
+         * The relay-chain aborted the upgrade process.
+         **/
+        ValidationFunctionDiscarded: GenericPalletEvent<'ParachainSystem', 'ValidationFunctionDiscarded', null>;
+        /**
+         * Some downward messages have been received and will be processed.
+         **/
+        DownwardMessagesReceived: GenericPalletEvent<'ParachainSystem', 'DownwardMessagesReceived', {
+            count: number;
+        }>;
+        /**
+         * Downward messages were processed using the given weight.
+         **/
+        DownwardMessagesProcessed: GenericPalletEvent<'ParachainSystem', 'DownwardMessagesProcessed', {
+            weightUsed: SpWeightsWeightV2Weight;
+            dmqHead: H256;
+        }>;
+        /**
+         * An upward message was sent to the relay chain.
+         **/
+        UpwardMessageSent: GenericPalletEvent<'ParachainSystem', 'UpwardMessageSent', {
+            messageHash?: FixedBytes<32> | undefined;
+        }>;
+        /**
+         * 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 `AssetTxPayment`'s events
+     **/
+    assetTxPayment: {
+        /**
+         * A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee,
+         * has been paid by `who` in an asset `asset_id`.
+         **/
+        AssetTxFeePaid: GenericPalletEvent<'AssetTxPayment', 'AssetTxFeePaid', {
+            who: AccountId32;
+            actualFee: bigint;
+            tip: bigint;
+            assetId: StagingXcmV3MultilocationMultiLocation;
+        }>;
+        /**
+         * A swap of the refund in native currency back to asset failed.
+         **/
+        AssetRefundFailed: GenericPalletEvent<'AssetTxPayment', 'AssetRefundFailed', {
+            nativeAmountKept: bigint;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `CollatorSelection`'s events
+     **/
+    collatorSelection: {
+        /**
+         * New Invulnerables were set.
+         **/
+        NewInvulnerables: GenericPalletEvent<'CollatorSelection', 'NewInvulnerables', {
+            invulnerables: Array<AccountId32>;
+        }>;
+        /**
+         * A new Invulnerable was added.
+         **/
+        InvulnerableAdded: GenericPalletEvent<'CollatorSelection', 'InvulnerableAdded', {
+            accountId: AccountId32;
+        }>;
+        /**
+         * An Invulnerable was removed.
+         **/
+        InvulnerableRemoved: GenericPalletEvent<'CollatorSelection', 'InvulnerableRemoved', {
+            accountId: AccountId32;
+        }>;
+        /**
+         * The number of desired candidates was set.
+         **/
+        NewDesiredCandidates: GenericPalletEvent<'CollatorSelection', 'NewDesiredCandidates', {
+            desiredCandidates: number;
+        }>;
+        /**
+         * The candidacy bond was set.
+         **/
+        NewCandidacyBond: GenericPalletEvent<'CollatorSelection', 'NewCandidacyBond', {
+            bondAmount: bigint;
+        }>;
+        /**
+         * A new candidate joined.
+         **/
+        CandidateAdded: GenericPalletEvent<'CollatorSelection', 'CandidateAdded', {
+            accountId: AccountId32;
+            deposit: bigint;
+        }>;
+        /**
+         * Bond of a candidate updated.
+         **/
+        CandidateBondUpdated: GenericPalletEvent<'CollatorSelection', 'CandidateBondUpdated', {
+            accountId: AccountId32;
+            deposit: bigint;
+        }>;
+        /**
+         * A candidate was removed.
+         **/
+        CandidateRemoved: GenericPalletEvent<'CollatorSelection', 'CandidateRemoved', {
+            accountId: AccountId32;
+        }>;
+        /**
+         * An account was replaced in the candidate list by another one.
+         **/
+        CandidateReplaced: GenericPalletEvent<'CollatorSelection', 'CandidateReplaced', {
+            old: AccountId32;
+            new: AccountId32;
+            deposit: bigint;
+        }>;
+        /**
+         * An account was unable to be added to the Invulnerables because they did not have keys
+         * registered. Other Invulnerables may have been set.
+         **/
+        InvalidInvulnerableSkipped: GenericPalletEvent<'CollatorSelection', 'InvalidInvulnerableSkipped', {
+            accountId: AccountId32;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Session`'s events
+     **/
+    session: {
+        /**
+         * New session has happened. Note that the argument is the session index, not the
+         * block number as the type might suggest.
+         **/
+        NewSession: GenericPalletEvent<'Session', 'NewSession', {
+            sessionIndex: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `XcmpQueue`'s events
+     **/
+    xcmpQueue: {
+        /**
+         * An HRMP message was sent to a sibling parachain.
+         **/
+        XcmpMessageSent: GenericPalletEvent<'XcmpQueue', 'XcmpMessageSent', {
+            messageHash: FixedBytes<32>;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `PolkadotXcm`'s events
+     **/
+    polkadotXcm: {
+        /**
+         * Execution of an XCM message was attempted.
+         **/
+        Attempted: GenericPalletEvent<'PolkadotXcm', 'Attempted', {
+            outcome: StagingXcmV4TraitsOutcome;
+        }>;
+        /**
+         * A XCM message was sent.
+         **/
+        Sent: GenericPalletEvent<'PolkadotXcm', 'Sent', {
+            origin: StagingXcmV4Location;
+            destination: StagingXcmV4Location;
+            message: StagingXcmV4Xcm;
+            messageId: FixedBytes<32>;
+        }>;
+        /**
+         * Query response received which does not match a registered query. This may be because a
+         * matching query was never registered, it may be because it is a duplicate response, or
+         * because the query timed out.
+         **/
+        UnexpectedResponse: GenericPalletEvent<'PolkadotXcm', 'UnexpectedResponse', {
+            origin: StagingXcmV4Location;
+            queryId: bigint;
+        }>;
+        /**
+         * Query response has been received and is ready for taking with `take_response`. There is
+         * no registered notification call.
+         **/
+        ResponseReady: GenericPalletEvent<'PolkadotXcm', 'ResponseReady', {
+            queryId: bigint;
+            response: StagingXcmV4Response;
+        }>;
+        /**
+         * Query response has been received and query is removed. The registered notification has
+         * been dispatched and executed successfully.
+         **/
+        Notified: GenericPalletEvent<'PolkadotXcm', 'Notified', {
+            queryId: bigint;
+            palletIndex: number;
+            callIndex: number;
+        }>;
+        /**
+         * Query response has been received and query is removed. The registered notification
+         * could not be dispatched because the dispatch weight is greater than the maximum weight
+         * originally budgeted by this runtime for the query result.
+         **/
+        NotifyOverweight: GenericPalletEvent<'PolkadotXcm', 'NotifyOverweight', {
+            queryId: bigint;
+            palletIndex: number;
+            callIndex: number;
+            actualWeight: SpWeightsWeightV2Weight;
+            maxBudgetedWeight: SpWeightsWeightV2Weight;
+        }>;
+        /**
+         * Query response has been received and query is removed. There was a general error with
+         * dispatching the notification call.
+         **/
+        NotifyDispatchError: GenericPalletEvent<'PolkadotXcm', 'NotifyDispatchError', {
+            queryId: bigint;
+            palletIndex: number;
+            callIndex: number;
+        }>;
+        /**
+         * Query response has been received and query is removed. The dispatch was unable to be
+         * decoded into a `Call`; this might be due to dispatch function having a signature which
+         * is not `(origin, QueryId, Response)`.
+         **/
+        NotifyDecodeFailed: GenericPalletEvent<'PolkadotXcm', 'NotifyDecodeFailed', {
+            queryId: bigint;
+            palletIndex: number;
+            callIndex: number;
+        }>;
+        /**
+         * Expected query response has been received but the origin location of the response does
+         * not match that expected. The query remains registered for a later, valid, response to
+         * be received and acted upon.
+         **/
+        InvalidResponder: GenericPalletEvent<'PolkadotXcm', 'InvalidResponder', {
+            origin: StagingXcmV4Location;
+            queryId: bigint;
+            expectedLocation?: StagingXcmV4Location | undefined;
+        }>;
+        /**
+         * Expected query response has been received but the expected origin location placed in
+         * storage by this runtime previously cannot be decoded. The query remains registered.
+         *
+         * This is unexpected (since a location placed in storage in a previously executing
+         * runtime should be readable prior to query timeout) and dangerous since the possibly
+         * valid response will be dropped. Manual governance intervention is probably going to be
+         * needed.
+         **/
+        InvalidResponderVersion: GenericPalletEvent<'PolkadotXcm', 'InvalidResponderVersion', {
+            origin: StagingXcmV4Location;
+            queryId: bigint;
+        }>;
+        /**
+         * Received query response has been read and removed.
+         **/
+        ResponseTaken: GenericPalletEvent<'PolkadotXcm', 'ResponseTaken', {
+            queryId: bigint;
+        }>;
+        /**
+         * Some assets have been placed in an asset trap.
+         **/
+        AssetsTrapped: GenericPalletEvent<'PolkadotXcm', 'AssetsTrapped', {
+            hash: H256;
+            origin: StagingXcmV4Location;
+            assets: XcmVersionedAssets;
+        }>;
+        /**
+         * An XCM version change notification message has been attempted to be sent.
+         *
+         * The cost of sending it (borne by the chain) is included.
+         **/
+        VersionChangeNotified: GenericPalletEvent<'PolkadotXcm', 'VersionChangeNotified', {
+            destination: StagingXcmV4Location;
+            result: number;
+            cost: StagingXcmV4AssetAssets;
+            messageId: FixedBytes<32>;
+        }>;
+        /**
+         * The supported version of a location has been changed. This might be through an
+         * automatic notification or a manual intervention.
+         **/
+        SupportedVersionChanged: GenericPalletEvent<'PolkadotXcm', 'SupportedVersionChanged', {
+            location: StagingXcmV4Location;
+            version: number;
+        }>;
+        /**
+         * A given location which had a version change subscription was dropped owing to an error
+         * sending the notification to it.
+         **/
+        NotifyTargetSendFail: GenericPalletEvent<'PolkadotXcm', 'NotifyTargetSendFail', {
+            location: StagingXcmV4Location;
+            queryId: bigint;
+            error: XcmV3TraitsError;
+        }>;
+        /**
+         * A given location which had a version change subscription was dropped owing to an error
+         * migrating the location to our new XCM format.
+         **/
+        NotifyTargetMigrationFail: GenericPalletEvent<'PolkadotXcm', 'NotifyTargetMigrationFail', {
+            location: XcmVersionedLocation;
+            queryId: bigint;
+        }>;
+        /**
+         * Expected query response has been received but the expected querier location placed in
+         * storage by this runtime previously cannot be decoded. The query remains registered.
+         *
+         * This is unexpected (since a location placed in storage in a previously executing
+         * runtime should be readable prior to query timeout) and dangerous since the possibly
+         * valid response will be dropped. Manual governance intervention is probably going to be
+         * needed.
+         **/
+        InvalidQuerierVersion: GenericPalletEvent<'PolkadotXcm', 'InvalidQuerierVersion', {
+            origin: StagingXcmV4Location;
+            queryId: bigint;
+        }>;
+        /**
+         * Expected query response has been received but the querier location of the response does
+         * not match the expected. The query remains registered for a later, valid, response to
+         * be received and acted upon.
+         **/
+        InvalidQuerier: GenericPalletEvent<'PolkadotXcm', 'InvalidQuerier', {
+            origin: StagingXcmV4Location;
+            queryId: bigint;
+            expectedQuerier: StagingXcmV4Location;
+            maybeActualQuerier?: StagingXcmV4Location | undefined;
+        }>;
+        /**
+         * A remote has requested XCM version change notification from us and we have honored it.
+         * A version information message is sent to them and its cost is included.
+         **/
+        VersionNotifyStarted: GenericPalletEvent<'PolkadotXcm', 'VersionNotifyStarted', {
+            destination: StagingXcmV4Location;
+            cost: StagingXcmV4AssetAssets;
+            messageId: FixedBytes<32>;
+        }>;
+        /**
+         * We have requested that a remote chain send us XCM version change notifications.
+         **/
+        VersionNotifyRequested: GenericPalletEvent<'PolkadotXcm', 'VersionNotifyRequested', {
+            destination: StagingXcmV4Location;
+            cost: StagingXcmV4AssetAssets;
+            messageId: FixedBytes<32>;
+        }>;
+        /**
+         * We have requested that a remote chain stops sending us XCM version change
+         * notifications.
+         **/
+        VersionNotifyUnrequested: GenericPalletEvent<'PolkadotXcm', 'VersionNotifyUnrequested', {
+            destination: StagingXcmV4Location;
+            cost: StagingXcmV4AssetAssets;
+            messageId: FixedBytes<32>;
+        }>;
+        /**
+         * Fees were paid from a location for an operation (often for using `SendXcm`).
+         **/
+        FeesPaid: GenericPalletEvent<'PolkadotXcm', 'FeesPaid', {
+            paying: StagingXcmV4Location;
+            fees: StagingXcmV4AssetAssets;
+        }>;
+        /**
+         * Some assets have been claimed from an asset trap
+         **/
+        AssetsClaimed: GenericPalletEvent<'PolkadotXcm', 'AssetsClaimed', {
+            hash: H256;
+            origin: StagingXcmV4Location;
+            assets: XcmVersionedAssets;
+        }>;
+        /**
+         * A XCM version migration finished.
+         **/
+        VersionMigrationFinished: GenericPalletEvent<'PolkadotXcm', 'VersionMigrationFinished', {
+            version: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `CumulusXcm`'s events
+     **/
+    cumulusXcm: {
+        /**
+         * Downward message is invalid XCM.
+         * \[ id \]
+         **/
+        InvalidFormat: GenericPalletEvent<'CumulusXcm', 'InvalidFormat', FixedBytes<32>>;
+        /**
+         * Downward message is unsupported version of XCM.
+         * \[ id \]
+         **/
+        UnsupportedVersion: GenericPalletEvent<'CumulusXcm', 'UnsupportedVersion', FixedBytes<32>>;
+        /**
+         * Downward message executed with the given outcome.
+         * \[ id, outcome \]
+         **/
+        ExecutedDownward: GenericPalletEvent<'CumulusXcm', 'ExecutedDownward', [FixedBytes<32>, StagingXcmV4TraitsOutcome]>;
+        /**
+         * 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: CumulusPrimitivesCoreAggregateMessageOrigin;
+            /**
+             * 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: CumulusPrimitivesCoreAggregateMessageOrigin;
+            /**
+             * 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: CumulusPrimitivesCoreAggregateMessageOrigin;
+            /**
+             * 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: CumulusPrimitivesCoreAggregateMessageOrigin;
+            /**
+             * The index of the page.
+             **/
+            index: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Utility`'s events
+     **/
+    utility: {
+        /**
+         * Batch of dispatches did not complete fully. Index of first failing dispatch given, as
+         * well as the error.
+         **/
+        BatchInterrupted: GenericPalletEvent<'Utility', 'BatchInterrupted', {
+            index: number;
+            error: DispatchError;
+        }>;
+        /**
+         * Batch of dispatches completed fully with no error.
+         **/
+        BatchCompleted: GenericPalletEvent<'Utility', 'BatchCompleted', null>;
+        /**
+         * Batch of dispatches completed but has errors.
+         **/
+        BatchCompletedWithErrors: GenericPalletEvent<'Utility', 'BatchCompletedWithErrors', null>;
+        /**
+         * A single item within a Batch of dispatches has completed with no error.
+         **/
+        ItemCompleted: GenericPalletEvent<'Utility', 'ItemCompleted', null>;
+        /**
+         * A single item within a Batch of dispatches has completed with error.
+         **/
+        ItemFailed: GenericPalletEvent<'Utility', 'ItemFailed', {
+            error: DispatchError;
+        }>;
+        /**
+         * A call was dispatched.
+         **/
+        DispatchedAs: GenericPalletEvent<'Utility', 'DispatchedAs', {
+            result: Result<[], DispatchError>;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Multisig`'s events
+     **/
+    multisig: {
+        /**
+         * A new multisig operation has begun.
+         **/
+        NewMultisig: GenericPalletEvent<'Multisig', 'NewMultisig', {
+            approving: AccountId32;
+            multisig: AccountId32;
+            callHash: FixedBytes<32>;
+        }>;
+        /**
+         * A multisig operation has been approved by someone.
+         **/
+        MultisigApproval: GenericPalletEvent<'Multisig', 'MultisigApproval', {
+            approving: AccountId32;
+            timepoint: PalletMultisigTimepoint;
+            multisig: AccountId32;
+            callHash: FixedBytes<32>;
+        }>;
+        /**
+         * A multisig operation has been executed.
+         **/
+        MultisigExecuted: GenericPalletEvent<'Multisig', 'MultisigExecuted', {
+            approving: AccountId32;
+            timepoint: PalletMultisigTimepoint;
+            multisig: AccountId32;
+            callHash: FixedBytes<32>;
+            result: Result<[], DispatchError>;
+        }>;
+        /**
+         * A multisig operation has been cancelled.
+         **/
+        MultisigCancelled: GenericPalletEvent<'Multisig', 'MultisigCancelled', {
+            cancelling: AccountId32;
+            timepoint: PalletMultisigTimepoint;
+            multisig: AccountId32;
+            callHash: FixedBytes<32>;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `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: AssetHubRococoRuntimeProxyType;
+            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: AssetHubRococoRuntimeProxyType;
+            delay: number;
+        }>;
+        /**
+         * A proxy was removed.
+         **/
+        ProxyRemoved: GenericPalletEvent<'Proxy', 'ProxyRemoved', {
+            delegator: AccountId32;
+            delegatee: AccountId32;
+            proxyType: AssetHubRococoRuntimeProxyType;
+            delay: number;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `Assets`'s events
+     **/
+    assets: {
+        /**
+         * Some asset class was created.
+         **/
+        Created: GenericPalletEvent<'Assets', 'Created', {
+            assetId: number;
+            creator: AccountId32;
+            owner: AccountId32;
+        }>;
+        /**
+         * Some assets were issued.
+         **/
+        Issued: GenericPalletEvent<'Assets', 'Issued', {
+            assetId: number;
+            owner: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some assets were transferred.
+         **/
+        Transferred: GenericPalletEvent<'Assets', 'Transferred', {
+            assetId: number;
+            from: AccountId32;
+            to: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some assets were destroyed.
+         **/
+        Burned: GenericPalletEvent<'Assets', 'Burned', {
+            assetId: number;
+            owner: AccountId32;
+            balance: bigint;
+        }>;
+        /**
+         * The management team changed.
+         **/
+        TeamChanged: GenericPalletEvent<'Assets', 'TeamChanged', {
+            assetId: number;
+            issuer: AccountId32;
+            admin: AccountId32;
+            freezer: AccountId32;
+        }>;
+        /**
+         * The owner changed.
+         **/
+        OwnerChanged: GenericPalletEvent<'Assets', 'OwnerChanged', {
+            assetId: number;
+            owner: AccountId32;
+        }>;
+        /**
+         * Some account `who` was frozen.
+         **/
+        Frozen: GenericPalletEvent<'Assets', 'Frozen', {
+            assetId: number;
+            who: AccountId32;
+        }>;
+        /**
+         * Some account `who` was thawed.
+         **/
+        Thawed: GenericPalletEvent<'Assets', 'Thawed', {
+            assetId: number;
+            who: AccountId32;
+        }>;
+        /**
+         * Some asset `asset_id` was frozen.
+         **/
+        AssetFrozen: GenericPalletEvent<'Assets', 'AssetFrozen', {
+            assetId: number;
+        }>;
+        /**
+         * Some asset `asset_id` was thawed.
+         **/
+        AssetThawed: GenericPalletEvent<'Assets', 'AssetThawed', {
+            assetId: number;
+        }>;
+        /**
+         * Accounts were destroyed for given asset.
+         **/
+        AccountsDestroyed: GenericPalletEvent<'Assets', 'AccountsDestroyed', {
+            assetId: number;
+            accountsDestroyed: number;
+            accountsRemaining: number;
+        }>;
+        /**
+         * Approvals were destroyed for given asset.
+         **/
+        ApprovalsDestroyed: GenericPalletEvent<'Assets', 'ApprovalsDestroyed', {
+            assetId: number;
+            approvalsDestroyed: number;
+            approvalsRemaining: number;
+        }>;
+        /**
+         * An asset class is in the process of being destroyed.
+         **/
+        DestructionStarted: GenericPalletEvent<'Assets', 'DestructionStarted', {
+            assetId: number;
+        }>;
+        /**
+         * An asset class was destroyed.
+         **/
+        Destroyed: GenericPalletEvent<'Assets', 'Destroyed', {
+            assetId: number;
+        }>;
+        /**
+         * Some asset class was force-created.
+         **/
+        ForceCreated: GenericPalletEvent<'Assets', 'ForceCreated', {
+            assetId: number;
+            owner: AccountId32;
+        }>;
+        /**
+         * New metadata has been set for an asset.
+         **/
+        MetadataSet: GenericPalletEvent<'Assets', 'MetadataSet', {
+            assetId: number;
+            name: Bytes;
+            symbol: Bytes;
+            decimals: number;
+            isFrozen: boolean;
+        }>;
+        /**
+         * Metadata has been cleared for an asset.
+         **/
+        MetadataCleared: GenericPalletEvent<'Assets', 'MetadataCleared', {
+            assetId: number;
+        }>;
+        /**
+         * (Additional) funds have been approved for transfer to a destination account.
+         **/
+        ApprovedTransfer: GenericPalletEvent<'Assets', 'ApprovedTransfer', {
+            assetId: number;
+            source: AccountId32;
+            delegate: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An approval for account `delegate` was cancelled by `owner`.
+         **/
+        ApprovalCancelled: GenericPalletEvent<'Assets', 'ApprovalCancelled', {
+            assetId: number;
+            owner: AccountId32;
+            delegate: AccountId32;
+        }>;
+        /**
+         * An `amount` was transferred in its entirety from `owner` to `destination` by
+         * the approved `delegate`.
+         **/
+        TransferredApproved: GenericPalletEvent<'Assets', 'TransferredApproved', {
+            assetId: number;
+            owner: AccountId32;
+            delegate: AccountId32;
+            destination: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An asset has had its attributes changed by the `Force` origin.
+         **/
+        AssetStatusChanged: GenericPalletEvent<'Assets', 'AssetStatusChanged', {
+            assetId: number;
+        }>;
+        /**
+         * The min_balance of an asset has been updated by the asset owner.
+         **/
+        AssetMinBalanceChanged: GenericPalletEvent<'Assets', 'AssetMinBalanceChanged', {
+            assetId: number;
+            newMinBalance: bigint;
+        }>;
+        /**
+         * Some account `who` was created with a deposit from `depositor`.
+         **/
+        Touched: GenericPalletEvent<'Assets', 'Touched', {
+            assetId: number;
+            who: AccountId32;
+            depositor: AccountId32;
+        }>;
+        /**
+         * Some account `who` was blocked.
+         **/
+        Blocked: GenericPalletEvent<'Assets', 'Blocked', {
+            assetId: number;
+            who: AccountId32;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `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 `ForeignAssets`'s events
+     **/
+    foreignAssets: {
+        /**
+         * Some asset class was created.
+         **/
+        Created: GenericPalletEvent<'ForeignAssets', 'Created', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            creator: AccountId32;
+            owner: AccountId32;
+        }>;
+        /**
+         * Some assets were issued.
+         **/
+        Issued: GenericPalletEvent<'ForeignAssets', 'Issued', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            owner: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some assets were transferred.
+         **/
+        Transferred: GenericPalletEvent<'ForeignAssets', 'Transferred', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            from: AccountId32;
+            to: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some assets were destroyed.
+         **/
+        Burned: GenericPalletEvent<'ForeignAssets', 'Burned', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            owner: AccountId32;
+            balance: bigint;
+        }>;
+        /**
+         * The management team changed.
+         **/
+        TeamChanged: GenericPalletEvent<'ForeignAssets', 'TeamChanged', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            issuer: AccountId32;
+            admin: AccountId32;
+            freezer: AccountId32;
+        }>;
+        /**
+         * The owner changed.
+         **/
+        OwnerChanged: GenericPalletEvent<'ForeignAssets', 'OwnerChanged', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            owner: AccountId32;
+        }>;
+        /**
+         * Some account `who` was frozen.
+         **/
+        Frozen: GenericPalletEvent<'ForeignAssets', 'Frozen', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            who: AccountId32;
+        }>;
+        /**
+         * Some account `who` was thawed.
+         **/
+        Thawed: GenericPalletEvent<'ForeignAssets', 'Thawed', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            who: AccountId32;
+        }>;
+        /**
+         * Some asset `asset_id` was frozen.
+         **/
+        AssetFrozen: GenericPalletEvent<'ForeignAssets', 'AssetFrozen', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+        }>;
+        /**
+         * Some asset `asset_id` was thawed.
+         **/
+        AssetThawed: GenericPalletEvent<'ForeignAssets', 'AssetThawed', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+        }>;
+        /**
+         * Accounts were destroyed for given asset.
+         **/
+        AccountsDestroyed: GenericPalletEvent<'ForeignAssets', 'AccountsDestroyed', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            accountsDestroyed: number;
+            accountsRemaining: number;
+        }>;
+        /**
+         * Approvals were destroyed for given asset.
+         **/
+        ApprovalsDestroyed: GenericPalletEvent<'ForeignAssets', 'ApprovalsDestroyed', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            approvalsDestroyed: number;
+            approvalsRemaining: number;
+        }>;
+        /**
+         * An asset class is in the process of being destroyed.
+         **/
+        DestructionStarted: GenericPalletEvent<'ForeignAssets', 'DestructionStarted', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+        }>;
+        /**
+         * An asset class was destroyed.
+         **/
+        Destroyed: GenericPalletEvent<'ForeignAssets', 'Destroyed', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+        }>;
+        /**
+         * Some asset class was force-created.
+         **/
+        ForceCreated: GenericPalletEvent<'ForeignAssets', 'ForceCreated', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            owner: AccountId32;
+        }>;
+        /**
+         * New metadata has been set for an asset.
+         **/
+        MetadataSet: GenericPalletEvent<'ForeignAssets', 'MetadataSet', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            name: Bytes;
+            symbol: Bytes;
+            decimals: number;
+            isFrozen: boolean;
+        }>;
+        /**
+         * Metadata has been cleared for an asset.
+         **/
+        MetadataCleared: GenericPalletEvent<'ForeignAssets', 'MetadataCleared', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+        }>;
+        /**
+         * (Additional) funds have been approved for transfer to a destination account.
+         **/
+        ApprovedTransfer: GenericPalletEvent<'ForeignAssets', 'ApprovedTransfer', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            source: AccountId32;
+            delegate: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An approval for account `delegate` was cancelled by `owner`.
+         **/
+        ApprovalCancelled: GenericPalletEvent<'ForeignAssets', 'ApprovalCancelled', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            owner: AccountId32;
+            delegate: AccountId32;
+        }>;
+        /**
+         * An `amount` was transferred in its entirety from `owner` to `destination` by
+         * the approved `delegate`.
+         **/
+        TransferredApproved: GenericPalletEvent<'ForeignAssets', 'TransferredApproved', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            owner: AccountId32;
+            delegate: AccountId32;
+            destination: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An asset has had its attributes changed by the `Force` origin.
+         **/
+        AssetStatusChanged: GenericPalletEvent<'ForeignAssets', 'AssetStatusChanged', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+        }>;
+        /**
+         * The min_balance of an asset has been updated by the asset owner.
+         **/
+        AssetMinBalanceChanged: GenericPalletEvent<'ForeignAssets', 'AssetMinBalanceChanged', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            newMinBalance: bigint;
+        }>;
+        /**
+         * Some account `who` was created with a deposit from `depositor`.
+         **/
+        Touched: GenericPalletEvent<'ForeignAssets', 'Touched', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            who: AccountId32;
+            depositor: AccountId32;
+        }>;
+        /**
+         * Some account `who` was blocked.
+         **/
+        Blocked: GenericPalletEvent<'ForeignAssets', 'Blocked', {
+            assetId: StagingXcmV3MultilocationMultiLocation;
+            who: AccountId32;
+        }>;
+        /**
+         * 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 `PoolAssets`'s events
+     **/
+    poolAssets: {
+        /**
+         * Some asset class was created.
+         **/
+        Created: GenericPalletEvent<'PoolAssets', 'Created', {
+            assetId: number;
+            creator: AccountId32;
+            owner: AccountId32;
+        }>;
+        /**
+         * Some assets were issued.
+         **/
+        Issued: GenericPalletEvent<'PoolAssets', 'Issued', {
+            assetId: number;
+            owner: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some assets were transferred.
+         **/
+        Transferred: GenericPalletEvent<'PoolAssets', 'Transferred', {
+            assetId: number;
+            from: AccountId32;
+            to: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * Some assets were destroyed.
+         **/
+        Burned: GenericPalletEvent<'PoolAssets', 'Burned', {
+            assetId: number;
+            owner: AccountId32;
+            balance: bigint;
+        }>;
+        /**
+         * The management team changed.
+         **/
+        TeamChanged: GenericPalletEvent<'PoolAssets', 'TeamChanged', {
+            assetId: number;
+            issuer: AccountId32;
+            admin: AccountId32;
+            freezer: AccountId32;
+        }>;
+        /**
+         * The owner changed.
+         **/
+        OwnerChanged: GenericPalletEvent<'PoolAssets', 'OwnerChanged', {
+            assetId: number;
+            owner: AccountId32;
+        }>;
+        /**
+         * Some account `who` was frozen.
+         **/
+        Frozen: GenericPalletEvent<'PoolAssets', 'Frozen', {
+            assetId: number;
+            who: AccountId32;
+        }>;
+        /**
+         * Some account `who` was thawed.
+         **/
+        Thawed: GenericPalletEvent<'PoolAssets', 'Thawed', {
+            assetId: number;
+            who: AccountId32;
+        }>;
+        /**
+         * Some asset `asset_id` was frozen.
+         **/
+        AssetFrozen: GenericPalletEvent<'PoolAssets', 'AssetFrozen', {
+            assetId: number;
+        }>;
+        /**
+         * Some asset `asset_id` was thawed.
+         **/
+        AssetThawed: GenericPalletEvent<'PoolAssets', 'AssetThawed', {
+            assetId: number;
+        }>;
+        /**
+         * Accounts were destroyed for given asset.
+         **/
+        AccountsDestroyed: GenericPalletEvent<'PoolAssets', 'AccountsDestroyed', {
+            assetId: number;
+            accountsDestroyed: number;
+            accountsRemaining: number;
+        }>;
+        /**
+         * Approvals were destroyed for given asset.
+         **/
+        ApprovalsDestroyed: GenericPalletEvent<'PoolAssets', 'ApprovalsDestroyed', {
+            assetId: number;
+            approvalsDestroyed: number;
+            approvalsRemaining: number;
+        }>;
+        /**
+         * An asset class is in the process of being destroyed.
+         **/
+        DestructionStarted: GenericPalletEvent<'PoolAssets', 'DestructionStarted', {
+            assetId: number;
+        }>;
+        /**
+         * An asset class was destroyed.
+         **/
+        Destroyed: GenericPalletEvent<'PoolAssets', 'Destroyed', {
+            assetId: number;
+        }>;
+        /**
+         * Some asset class was force-created.
+         **/
+        ForceCreated: GenericPalletEvent<'PoolAssets', 'ForceCreated', {
+            assetId: number;
+            owner: AccountId32;
+        }>;
+        /**
+         * New metadata has been set for an asset.
+         **/
+        MetadataSet: GenericPalletEvent<'PoolAssets', 'MetadataSet', {
+            assetId: number;
+            name: Bytes;
+            symbol: Bytes;
+            decimals: number;
+            isFrozen: boolean;
+        }>;
+        /**
+         * Metadata has been cleared for an asset.
+         **/
+        MetadataCleared: GenericPalletEvent<'PoolAssets', 'MetadataCleared', {
+            assetId: number;
+        }>;
+        /**
+         * (Additional) funds have been approved for transfer to a destination account.
+         **/
+        ApprovedTransfer: GenericPalletEvent<'PoolAssets', 'ApprovedTransfer', {
+            assetId: number;
+            source: AccountId32;
+            delegate: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An approval for account `delegate` was cancelled by `owner`.
+         **/
+        ApprovalCancelled: GenericPalletEvent<'PoolAssets', 'ApprovalCancelled', {
+            assetId: number;
+            owner: AccountId32;
+            delegate: AccountId32;
+        }>;
+        /**
+         * An `amount` was transferred in its entirety from `owner` to `destination` by
+         * the approved `delegate`.
+         **/
+        TransferredApproved: GenericPalletEvent<'PoolAssets', 'TransferredApproved', {
+            assetId: number;
+            owner: AccountId32;
+            delegate: AccountId32;
+            destination: AccountId32;
+            amount: bigint;
+        }>;
+        /**
+         * An asset has had its attributes changed by the `Force` origin.
+         **/
+        AssetStatusChanged: GenericPalletEvent<'PoolAssets', 'AssetStatusChanged', {
+            assetId: number;
+        }>;
+        /**
+         * The min_balance of an asset has been updated by the asset owner.
+         **/
+        AssetMinBalanceChanged: GenericPalletEvent<'PoolAssets', 'AssetMinBalanceChanged', {
+            assetId: number;
+            newMinBalance: bigint;
+        }>;
+        /**
+         * Some account `who` was created with a deposit from `depositor`.
+         **/
+        Touched: GenericPalletEvent<'PoolAssets', 'Touched', {
+            assetId: number;
+            who: AccountId32;
+            depositor: AccountId32;
+        }>;
+        /**
+         * Some account `who` was blocked.
+         **/
+        Blocked: GenericPalletEvent<'PoolAssets', 'Blocked', {
+            assetId: number;
+            who: AccountId32;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `AssetConversion`'s events
+     **/
+    assetConversion: {
+        /**
+         * A successful call of the `CretaPool` extrinsic will create this event.
+         **/
+        PoolCreated: GenericPalletEvent<'AssetConversion', 'PoolCreated', {
+            /**
+             * The account that created the pool.
+             **/
+            creator: AccountId32;
+            /**
+             * The pool id associated with the pool. Note that the order of the assets may not be
+             * the same as the order specified in the create pool extrinsic.
+             **/
+            poolId: [StagingXcmV3MultilocationMultiLocation, StagingXcmV3MultilocationMultiLocation];
+            /**
+             * 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: [StagingXcmV3MultilocationMultiLocation, StagingXcmV3MultilocationMultiLocation];
+            /**
+             * 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: [StagingXcmV3MultilocationMultiLocation, StagingXcmV3MultilocationMultiLocation];
+            /**
+             * 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<[StagingXcmV3MultilocationMultiLocation, 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<[StagingXcmV3MultilocationMultiLocation, bigint]>;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+}