@dedot/chaintypes 0.0.1-alpha.22

package/polkadotAssetHub/events.d.ts

@@ -0,0 +1,1787 @@
+import type { GenericChainEvents, GenericPalletEvent } from '@dedot/types';
+import type { DispatchInfo, DispatchError, AccountId32, H256, FixedBytes, Result, Bytes } from '@dedot/codecs';
+import type { SpWeightsWeightV2Weight, FrameSupportTokensMiscBalanceStatus, XcmV3TraitsError, PolkadotParachainPrimitivesPrimitivesId, XcmV3TraitsOutcome, StagingXcmV3MultilocationMultiLocation, XcmV3Xcm, XcmV3Response, XcmVersionedMultiAssets, XcmV3MultiassetMultiAssets, XcmVersionedMultiLocation, PalletMultisigTimepoint, AssetHubPolkadotRuntimeProxyType, 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;
+        }>;
+        /**
+         * 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>;
+        /**
+         * An upgrade has been authorized.
+         **/
+        UpgradeAuthorized: GenericPalletEvent<'ParachainSystem', 'UpgradeAuthorized', {
+            codeHash: H256;
+        }>;
+        /**
+         * 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;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `TransactionPayment`'s events
+     **/
+    transactionPayment: {
+        /**
+         * A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee,
+         * has been paid by `who`.
+         **/
+        TransactionFeePaid: GenericPalletEvent<'TransactionPayment', 'TransactionFeePaid', {
+            who: AccountId32;
+            actualFee: bigint;
+            tip: bigint;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `AssetTxPayment`'s events
+     **/
+    assetTxPayment: {
+        /**
+         * A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee,
+         * has been paid by `who` in an asset `asset_id`.
+         **/
+        AssetTxFeePaid: GenericPalletEvent<'AssetTxPayment', 'AssetTxFeePaid', {
+            who: AccountId32;
+            actualFee: bigint;
+            tip: bigint;
+            assetId?: number | undefined;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `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;
+        }>;
+        /**
+         * A candidate was removed.
+         **/
+        CandidateRemoved: GenericPalletEvent<'CollatorSelection', 'CandidateRemoved', {
+            accountId: AccountId32;
+        }>;
+        /**
+         * 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: {
+        /**
+         * Some XCM was executed ok.
+         **/
+        Success: GenericPalletEvent<'XcmpQueue', 'Success', {
+            messageHash: FixedBytes<32>;
+            messageId: FixedBytes<32>;
+            weight: SpWeightsWeightV2Weight;
+        }>;
+        /**
+         * Some XCM failed.
+         **/
+        Fail: GenericPalletEvent<'XcmpQueue', 'Fail', {
+            messageHash: FixedBytes<32>;
+            messageId: FixedBytes<32>;
+            error: XcmV3TraitsError;
+            weight: SpWeightsWeightV2Weight;
+        }>;
+        /**
+         * Bad XCM version used.
+         **/
+        BadVersion: GenericPalletEvent<'XcmpQueue', 'BadVersion', {
+            messageHash: FixedBytes<32>;
+        }>;
+        /**
+         * Bad XCM format used.
+         **/
+        BadFormat: GenericPalletEvent<'XcmpQueue', 'BadFormat', {
+            messageHash: FixedBytes<32>;
+        }>;
+        /**
+         * An HRMP message was sent to a sibling parachain.
+         **/
+        XcmpMessageSent: GenericPalletEvent<'XcmpQueue', 'XcmpMessageSent', {
+            messageHash: FixedBytes<32>;
+        }>;
+        /**
+         * An XCM exceeded the individual message weight budget.
+         **/
+        OverweightEnqueued: GenericPalletEvent<'XcmpQueue', 'OverweightEnqueued', {
+            sender: PolkadotParachainPrimitivesPrimitivesId;
+            sentAt: number;
+            index: bigint;
+            required: SpWeightsWeightV2Weight;
+        }>;
+        /**
+         * An XCM from the overweight queue was executed with the given actual weight used.
+         **/
+        OverweightServiced: GenericPalletEvent<'XcmpQueue', 'OverweightServiced', {
+            index: bigint;
+            used: SpWeightsWeightV2Weight;
+        }>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `PolkadotXcm`'s events
+     **/
+    polkadotXcm: {
+        /**
+         * Execution of an XCM message was attempted.
+         **/
+        Attempted: GenericPalletEvent<'PolkadotXcm', 'Attempted', {
+            outcome: XcmV3TraitsOutcome;
+        }>;
+        /**
+         * A XCM message was sent.
+         **/
+        Sent: GenericPalletEvent<'PolkadotXcm', 'Sent', {
+            origin: StagingXcmV3MultilocationMultiLocation;
+            destination: StagingXcmV3MultilocationMultiLocation;
+            message: XcmV3Xcm;
+            messageId: FixedBytes<32>;
+        }>;
+        /**
+         * Query response received which does not match a registered query. This may be because a
+         * matching query was never registered, it may be because it is a duplicate response, or
+         * because the query timed out.
+         **/
+        UnexpectedResponse: GenericPalletEvent<'PolkadotXcm', 'UnexpectedResponse', {
+            origin: StagingXcmV3MultilocationMultiLocation;
+            queryId: bigint;
+        }>;
+        /**
+         * Query response has been received and is ready for taking with `take_response`. There is
+         * no registered notification call.
+         **/
+        ResponseReady: GenericPalletEvent<'PolkadotXcm', 'ResponseReady', {
+            queryId: bigint;
+            response: XcmV3Response;
+        }>;
+        /**
+         * Query response has been received and query is removed. The registered notification has
+         * been dispatched and executed successfully.
+         **/
+        Notified: GenericPalletEvent<'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: StagingXcmV3MultilocationMultiLocation;
+            queryId: bigint;
+            expectedLocation?: StagingXcmV3MultilocationMultiLocation | undefined;
+        }>;
+        /**
+         * Expected query response has been received but the expected origin location placed in
+         * storage by this runtime previously cannot be decoded. The query remains registered.
+         *
+         * This is unexpected (since a location placed in storage in a previously executing
+         * runtime should be readable prior to query timeout) and dangerous since the possibly
+         * valid response will be dropped. Manual governance intervention is probably going to be
+         * needed.
+         **/
+        InvalidResponderVersion: GenericPalletEvent<'PolkadotXcm', 'InvalidResponderVersion', {
+            origin: StagingXcmV3MultilocationMultiLocation;
+            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: StagingXcmV3MultilocationMultiLocation;
+            assets: XcmVersionedMultiAssets;
+        }>;
+        /**
+         * An XCM version change notification message has been attempted to be sent.
+         *
+         * The cost of sending it (borne by the chain) is included.
+         **/
+        VersionChangeNotified: GenericPalletEvent<'PolkadotXcm', 'VersionChangeNotified', {
+            destination: StagingXcmV3MultilocationMultiLocation;
+            result: number;
+            cost: XcmV3MultiassetMultiAssets;
+            messageId: FixedBytes<32>;
+        }>;
+        /**
+         * The supported version of a location has been changed. This might be through an
+         * automatic notification or a manual intervention.
+         **/
+        SupportedVersionChanged: GenericPalletEvent<'PolkadotXcm', 'SupportedVersionChanged', {
+            location: StagingXcmV3MultilocationMultiLocation;
+            version: number;
+        }>;
+        /**
+         * A given location which had a version change subscription was dropped owing to an error
+         * sending the notification to it.
+         **/
+        NotifyTargetSendFail: GenericPalletEvent<'PolkadotXcm', 'NotifyTargetSendFail', {
+            location: StagingXcmV3MultilocationMultiLocation;
+            queryId: bigint;
+            error: XcmV3TraitsError;
+        }>;
+        /**
+         * A given location which had a version change subscription was dropped owing to an error
+         * migrating the location to our new XCM format.
+         **/
+        NotifyTargetMigrationFail: GenericPalletEvent<'PolkadotXcm', 'NotifyTargetMigrationFail', {
+            location: XcmVersionedMultiLocation;
+            queryId: bigint;
+        }>;
+        /**
+         * Expected query response has been received but the expected querier location placed in
+         * storage by this runtime previously cannot be decoded. The query remains registered.
+         *
+         * This is unexpected (since a location placed in storage in a previously executing
+         * runtime should be readable prior to query timeout) and dangerous since the possibly
+         * valid response will be dropped. Manual governance intervention is probably going to be
+         * needed.
+         **/
+        InvalidQuerierVersion: GenericPalletEvent<'PolkadotXcm', 'InvalidQuerierVersion', {
+            origin: StagingXcmV3MultilocationMultiLocation;
+            queryId: bigint;
+        }>;
+        /**
+         * Expected query response has been received but the querier location of the response does
+         * not match the expected. The query remains registered for a later, valid, response to
+         * be received and acted upon.
+         **/
+        InvalidQuerier: GenericPalletEvent<'PolkadotXcm', 'InvalidQuerier', {
+            origin: StagingXcmV3MultilocationMultiLocation;
+            queryId: bigint;
+            expectedQuerier: StagingXcmV3MultilocationMultiLocation;
+            maybeActualQuerier?: StagingXcmV3MultilocationMultiLocation | undefined;
+        }>;
+        /**
+         * A remote has requested XCM version change notification from us and we have honored it.
+         * A version information message is sent to them and its cost is included.
+         **/
+        VersionNotifyStarted: GenericPalletEvent<'PolkadotXcm', 'VersionNotifyStarted', {
+            destination: StagingXcmV3MultilocationMultiLocation;
+            cost: XcmV3MultiassetMultiAssets;
+            messageId: FixedBytes<32>;
+        }>;
+        /**
+         * We have requested that a remote chain send us XCM version change notifications.
+         **/
+        VersionNotifyRequested: GenericPalletEvent<'PolkadotXcm', 'VersionNotifyRequested', {
+            destination: StagingXcmV3MultilocationMultiLocation;
+            cost: XcmV3MultiassetMultiAssets;
+            messageId: FixedBytes<32>;
+        }>;
+        /**
+         * We have requested that a remote chain stops sending us XCM version change
+         * notifications.
+         **/
+        VersionNotifyUnrequested: GenericPalletEvent<'PolkadotXcm', 'VersionNotifyUnrequested', {
+            destination: StagingXcmV3MultilocationMultiLocation;
+            cost: XcmV3MultiassetMultiAssets;
+            messageId: FixedBytes<32>;
+        }>;
+        /**
+         * Fees were paid from a location for an operation (often for using `SendXcm`).
+         **/
+        FeesPaid: GenericPalletEvent<'PolkadotXcm', 'FeesPaid', {
+            paying: StagingXcmV3MultilocationMultiLocation;
+            fees: XcmV3MultiassetMultiAssets;
+        }>;
+        /**
+         * Some assets have been claimed from an asset trap
+         **/
+        AssetsClaimed: GenericPalletEvent<'PolkadotXcm', 'AssetsClaimed', {
+            hash: H256;
+            origin: StagingXcmV3MultilocationMultiLocation;
+            assets: XcmVersionedMultiAssets;
+        }>;
+        /**
+         * 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>, XcmV3TraitsOutcome]>;
+        /**
+         * Generic pallet event
+         **/
+        [prop: string]: GenericPalletEvent;
+    };
+    /**
+     * Pallet `DmpQueue`'s events
+     **/
+    dmpQueue: {
+        /**
+         * Downward message is invalid XCM.
+         **/
+        InvalidFormat: GenericPalletEvent<'DmpQueue', 'InvalidFormat', {
+            messageHash: FixedBytes<32>;
+        }>;
+        /**
+         * Downward message is unsupported version of XCM.
+         **/
+        UnsupportedVersion: GenericPalletEvent<'DmpQueue', 'UnsupportedVersion', {
+            messageHash: FixedBytes<32>;
+        }>;
+        /**
+         * Downward message executed with the given outcome.
+         **/
+        ExecutedDownward: GenericPalletEvent<'DmpQueue', 'ExecutedDownward', {
+            messageHash: FixedBytes<32>;
+            messageId: FixedBytes<32>;
+            outcome: XcmV3TraitsOutcome;
+        }>;
+        /**
+         * The weight limit for handling downward messages was reached.
+         **/
+        WeightExhausted: GenericPalletEvent<'DmpQueue', 'WeightExhausted', {
+            messageHash: FixedBytes<32>;
+            messageId: FixedBytes<32>;
+            remainingWeight: SpWeightsWeightV2Weight;
+            requiredWeight: SpWeightsWeightV2Weight;
+        }>;
+        /**
+         * Downward message is overweight and was placed in the overweight queue.
+         **/
+        OverweightEnqueued: GenericPalletEvent<'DmpQueue', 'OverweightEnqueued', {
+            messageHash: FixedBytes<32>;
+            messageId: FixedBytes<32>;
+            overweightIndex: bigint;
+            requiredWeight: SpWeightsWeightV2Weight;
+        }>;
+        /**
+         * Downward message from the overweight queue was executed.
+         **/
+        OverweightServiced: GenericPalletEvent<'DmpQueue', 'OverweightServiced', {
+            overweightIndex: bigint;
+            weightUsed: SpWeightsWeightV2Weight;
+        }>;
+        /**
+         * The maximum number of downward messages was reached.
+         **/
+        MaxMessagesExhausted: GenericPalletEvent<'DmpQueue', 'MaxMessagesExhausted', {
+            messageHash: FixedBytes<32>;
+        }>;
+        /**
+         * 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: AssetHubPolkadotRuntimeProxyType;
+            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: AssetHubPolkadotRuntimeProxyType;
+            delay: number;
+        }>;
+        /**
+         * A proxy was removed.
+         **/
+        ProxyRemoved: GenericPalletEvent<'Proxy', 'ProxyRemoved', {
+            delegator: AccountId32;
+            delegatee: AccountId32;
+            proxyType: AssetHubPolkadotRuntimeProxyType;
+            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;
+    };
+}