Type Alias dry_run_call

dry_run_call: RuntimeDescriptor<
    [
        origin: Enum<
            {
                CumulusXcm: Enum<{ Relay: undefined; SiblingParachain: number }>;
                PolkadotXcm: Enum<
                    {
                        Response: {
                            interior: Enum<
                                {
                                    Here: undefined;
                                    X1: Enum<(...)>;
                                    X2: FixedSizeArray<(...), (...)>;
                                    X3: FixedSizeArray<(...), (...)>;
                                    X4: FixedSizeArray<(...), (...)>;
                                    X5: FixedSizeArray<(...), (...)>;
                                    X6: FixedSizeArray<(...), (...)>;
                                    X7: FixedSizeArray<(...), (...)>;
                                    X8: FixedSizeArray<(...), (...)>;
                                },
                            >;
                            parents: number;
                        };
                        Xcm: {
                            interior: Enum<
                                {
                                    Here: undefined;
                                    X1: Enum<(...)>;
                                    X2: FixedSizeArray<(...), (...)>;
                                    X3: FixedSizeArray<(...), (...)>;
                                    X4: FixedSizeArray<(...), (...)>;
                                    X5: FixedSizeArray<(...), (...)>;
                                    X6: FixedSizeArray<(...), (...)>;
                                    X7: FixedSizeArray<(...), (...)>;
                                    X8: FixedSizeArray<(...), (...)>;
                                },
                            >;
                            parents: number;
                        };
                    },
                >;
                system: DispatchRawOrigin;
                Void: undefined;
            },
        >,
        call: TxCallData,
    ],
    ResultPayload<
        {
            emitted_events: Enum<
                {
                    AssetConversion: Enum<
                        {
                            LiquidityAdded: {
                                amount1_provided: bigint;
                                amount2_provided: bigint;
                                lp_token: number;
                                lp_token_minted: bigint;
                                mint_to: SS58String;
                                pool_id: FixedSizeArray<2, { interior: ...; parents: ... }>;
                                who: SS58String;
                            };
                            LiquidityRemoved: {
                                amount1: bigint;
                                amount2: bigint;
                                lp_token: number;
                                lp_token_burned: bigint;
                                pool_id: FixedSizeArray<2, { interior: ...; parents: ... }>;
                                who: SS58String;
                                withdraw_to: SS58String;
                                withdrawal_fee: number;
                            };
                            PoolCreated: {
                                creator: SS58String;
                                lp_token: number;
                                pool_account: SS58String;
                                pool_id: FixedSizeArray<2, { interior: ...; parents: ... }>;
                            };
                            SwapCreditExecuted: {
                                amount_in: bigint;
                                amount_out: bigint;
                                path: [(...), (...)][];
                            };
                            SwapExecuted: {
                                amount_in: bigint;
                                amount_out: bigint;
                                path: [(...), (...)][];
                                send_to: SS58String;
                                who: SS58String;
                            };
                            Touched: {
                                pool_id: FixedSizeArray<2, { interior: ...; parents: ... }>;
                                who: SS58String;
                            };
                        },
                    >;
                    AssetConversionMigration: Enum<
                        {
                            MigratedToNewAccount: {
                                new_account: SS58String;
                                pool_id: FixedSizeArray<2, { interior: ...; parents: ... }>;
                                prior_account: SS58String;
                            };
                        },
                    >;
                    AssetRewards: Enum<
                        {
                            PoolAdminModified: { new_admin: SS58String; pool_id: number };
                            PoolCleanedUp: { pool_id: number };
                            PoolCreated: {
                                admin: SS58String;
                                creator: SS58String;
                                expiry_block: number;
                                pool_id: number;
                                reward_asset_id: { interior: Enum<(...)>; parents: number };
                                reward_rate_per_block: bigint;
                                staked_asset_id: { interior: Enum<(...)>; parents: number };
                            };
                            PoolExpiryBlockModified: {
                                new_expiry_block: number;
                                pool_id: number;
                            };
                            PoolRewardRateModified: {
                                new_reward_rate_per_block: bigint;
                                pool_id: number;
                            };
                            RewardsHarvested: {
                                amount: bigint;
                                caller: SS58String;
                                pool_id: number;
                                staker: SS58String;
                            };
                            Staked: { amount: bigint; pool_id: number; staker: SS58String };
                            Unstaked: {
                                amount: bigint;
                                caller: SS58String;
                                pool_id: number;
                                staker: SS58String;
                            };
                        },
                    >;
                    Assets: Enum<
                        {
                            AccountsDestroyed: {
                                accounts_destroyed: number;
                                accounts_remaining: number;
                                asset_id: number;
                            };
                            ApprovalCancelled: {
                                asset_id: number;
                                delegate: SS58String;
                                owner: SS58String;
                            };
                            ApprovalsDestroyed: {
                                approvals_destroyed: number;
                                approvals_remaining: number;
                                asset_id: number;
                            };
                            ApprovedTransfer: {
                                amount: bigint;
                                asset_id: number;
                                delegate: SS58String;
                                source: SS58String;
                            };
                            AssetFrozen: { asset_id: number };
                            AssetMinBalanceChanged: { asset_id: number; new_min_balance: bigint };
                            AssetStatusChanged: { asset_id: number };
                            AssetThawed: { asset_id: number };
                            Blocked: { asset_id: number; who: SS58String };
                            Burned: { asset_id: number; balance: bigint; owner: SS58String };
                            Created: { asset_id: number; creator: SS58String; owner: SS58String };
                            Deposited: { amount: bigint; asset_id: number; who: SS58String };
                            Destroyed: { asset_id: number };
                            DestructionStarted: { asset_id: number };
                            ForceCreated: { asset_id: number; owner: SS58String };
                            Frozen: { asset_id: number; who: SS58String };
                            Issued: { amount: bigint; asset_id: number; owner: SS58String };
                            MetadataCleared: { asset_id: number };
                            MetadataSet: {
                                asset_id: number;
                                decimals: number;
                                is_frozen: boolean;
                                name: Binary;
                                symbol: Binary;
                            };
                            OwnerChanged: { asset_id: number; owner: SS58String };
                            TeamChanged: {
                                admin: SS58String;
                                asset_id: number;
                                freezer: SS58String;
                                issuer: SS58String;
                            };
                            Thawed: { asset_id: number; who: SS58String };
                            Touched: { asset_id: number; depositor: SS58String; who: SS58String };
                            Transferred: {
                                amount: bigint;
                                asset_id: number;
                                from: SS58String;
                                to: SS58String;
                            };
                            TransferredApproved: {
                                amount: bigint;
                                asset_id: number;
                                delegate: SS58String;
                                destination: SS58String;
                                owner: SS58String;
                            };
                            Withdrawn: { amount: bigint; asset_id: number; who: SS58String };
                        },
                    >;
                    AssetsFreezer: Enum<
                        {
                            Frozen: { amount: bigint; asset_id: number; who: SS58String };
                            Thawed: { amount: bigint; asset_id: number; who: SS58String };
                        },
                    >;
                    AssetTxPayment: Enum<
                        {
                            AssetRefundFailed: { native_amount_kept: bigint };
                            AssetTxFeePaid: {
                                actual_fee: bigint;
                                asset_id: { interior: Enum<(...)>; parents: number };
                                tip: bigint;
                                who: SS58String;
                            };
                        },
                    >;
                    Balances: Enum<
                        {
                            BalanceSet: { free: bigint; who: SS58String };
                            Burned: { amount: bigint; who: SS58String };
                            Deposit: { amount: bigint; who: SS58String };
                            DustLost: { account: SS58String; amount: bigint };
                            Endowed: { account: SS58String; free_balance: bigint };
                            Frozen: { amount: bigint; who: SS58String };
                            Issued: { amount: bigint };
                            Locked: { amount: bigint; who: SS58String };
                            Minted: { amount: bigint; who: SS58String };
                            Rescinded: { amount: bigint };
                            Reserved: { amount: bigint; who: SS58String };
                            ReserveRepatriated: {
                                amount: bigint;
                                destination_status: BalanceStatus;
                                from: SS58String;
                                to: SS58String;
                            };
                            Restored: { amount: bigint; who: SS58String };
                            Slashed: { amount: bigint; who: SS58String };
                            Suspended: { amount: bigint; who: SS58String };
                            Thawed: { amount: bigint; who: SS58String };
                            TotalIssuanceForced: { new: bigint; old: bigint };
                            Transfer: { amount: bigint; from: SS58String; to: SS58String };
                            Unlocked: { amount: bigint; who: SS58String };
                            Unreserved: { amount: bigint; who: SS58String };
                            Upgraded: { who: SS58String };
                            Withdraw: { amount: bigint; who: SS58String };
                        },
                    >;
                    CollatorSelection: Enum<
                        {
                            CandidateAdded: { account_id: SS58String; deposit: bigint };
                            CandidateBondUpdated: { account_id: SS58String; deposit: bigint };
                            CandidateRemoved: { account_id: SS58String };
                            CandidateReplaced: {
                                deposit: bigint;
                                new: SS58String;
                                old: SS58String;
                            };
                            InvalidInvulnerableSkipped: { account_id: SS58String };
                            InvulnerableAdded: { account_id: SS58String };
                            InvulnerableRemoved: { account_id: SS58String };
                            NewCandidacyBond: { bond_amount: bigint };
                            NewDesiredCandidates: { desired_candidates: number };
                            NewInvulnerables: { invulnerables: SS58String[] };
                        },
                    >;
                    CumulusXcm: Enum<
                        {
                            ExecutedDownward: [
                                FixedSizeBinary<32>,
                                Enum<{ Complete: ...; Error: ...; Incomplete: ... }>,
                            ];
                            InvalidFormat: FixedSizeBinary<32>;
                            UnsupportedVersion: FixedSizeBinary<32>;
                        },
                    >;
                    ForeignAssets: Enum<
                        {
                            AccountsDestroyed: {
                                accounts_destroyed: number;
                                accounts_remaining: number;
                                asset_id: { interior: Enum<(...)>; parents: number };
                            };
                            ApprovalCancelled: {
                                asset_id: { interior: Enum<(...)>; parents: number };
                                delegate: SS58String;
                                owner: SS58String;
                            };
                            ApprovalsDestroyed: {
                                approvals_destroyed: number;
                                approvals_remaining: number;
                                asset_id: { interior: Enum<(...)>; parents: number };
                            };
                            ApprovedTransfer: {
                                amount: bigint;
                                asset_id: { interior: Enum<(...)>; parents: number };
                                delegate: SS58String;
                                source: SS58String;
                            };
                            AssetFrozen: { asset_id: { interior: Enum<(...)>; parents: number } };
                            AssetMinBalanceChanged: {
                                asset_id: { interior: Enum<(...)>; parents: number };
                                new_min_balance: bigint;
                            };
                            AssetStatusChanged: {
                                asset_id: { interior: Enum<(...)>; parents: number };
                            };
                            AssetThawed: { asset_id: { interior: Enum<(...)>; parents: number } };
                            Blocked: {
                                asset_id: { interior: Enum<(...)>; parents: number };
                                who: SS58String;
                            };
                            Burned: {
                                asset_id: { interior: Enum<(...)>; parents: number };
                                balance: bigint;
                                owner: SS58String;
                            };
                            Created: {
                                asset_id: { interior: Enum<(...)>; parents: number };
                                creator: SS58String;
                                owner: SS58String;
                            };
                            Deposited: {
                                amount: bigint;
                                asset_id: { interior: Enum<(...)>; parents: number };
                                who: SS58String;
                            };
                            Destroyed: { asset_id: { interior: Enum<(...)>; parents: number } };
                            DestructionStarted: {
                                asset_id: { interior: Enum<(...)>; parents: number };
                            };
                            ForceCreated: {
                                asset_id: { interior: Enum<(...)>; parents: number };
                                owner: SS58String;
                            };
                            Frozen: {
                                asset_id: { interior: Enum<(...)>; parents: number };
                                who: SS58String;
                            };
                            Issued: {
                                amount: bigint;
                                asset_id: { interior: Enum<(...)>; parents: number };
                                owner: SS58String;
                            };
                            MetadataCleared: {
                                asset_id: { interior: Enum<(...)>; parents: number };
                            };
                            MetadataSet: {
                                asset_id: { interior: Enum<(...)>; parents: number };
                                decimals: number;
                                is_frozen: boolean;
                                name: Binary;
                                symbol: Binary;
                            };
                            OwnerChanged: {
                                asset_id: { interior: Enum<(...)>; parents: number };
                                owner: SS58String;
                            };
                            TeamChanged: {
                                admin: SS58String;
                                asset_id: { interior: Enum<(...)>; parents: number };
                                freezer: SS58String;
                                issuer: SS58String;
                            };
                            Thawed: {
                                asset_id: { interior: Enum<(...)>; parents: number };
                                who: SS58String;
                            };
                            Touched: {
                                asset_id: { interior: Enum<(...)>; parents: number };
                                depositor: SS58String;
                                who: SS58String;
                            };
                            Transferred: {
                                amount: bigint;
                                asset_id: { interior: Enum<(...)>; parents: number };
                                from: SS58String;
                                to: SS58String;
                            };
                            TransferredApproved: {
                                amount: bigint;
                                asset_id: { interior: Enum<(...)>; parents: number };
                                delegate: SS58String;
                                destination: SS58String;
                                owner: SS58String;
                            };
                            Withdrawn: {
                                amount: bigint;
                                asset_id: { interior: Enum<(...)>; parents: number };
                                who: SS58String;
                            };
                        },
                    >;
                    ForeignAssetsFreezer: Enum<
                        {
                            Frozen: {
                                amount: bigint;
                                asset_id: { interior: Enum<(...)>; parents: number };
                                who: SS58String;
                            };
                            Thawed: {
                                amount: bigint;
                                asset_id: { interior: Enum<(...)>; parents: number };
                                who: SS58String;
                            };
                        },
                    >;
                    MessageQueue: Enum<
                        {
                            OverweightEnqueued: {
                                id: FixedSizeBinary<32>;
                                message_index: number;
                                origin: Enum<{ Here: ...; Parent: ...; Sibling: ... }>;
                                page_index: number;
                            };
                            PageReaped: {
                                index: number;
                                origin: Enum<{ Here: ...; Parent: ...; Sibling: ... }>;
                            };
                            Processed: {
                                id: FixedSizeBinary<32>;
                                origin: Enum<{ Here: ...; Parent: ...; Sibling: ... }>;
                                success: boolean;
                                weight_used: { proof_size: bigint; ref_time: bigint };
                            };
                            ProcessingFailed: {
                                error: Enum<
                                    {
                                        BadFormat: ...;
                                        Corrupt: ...;
                                        Overweight: ...;
                                        StackLimitReached: ...;
                                        Unsupported: ...;
                                        Yield: ...;
                                    },
                                >;
                                id: FixedSizeBinary<32>;
                                origin: Enum<{ Here: ...; Parent: ...; Sibling: ... }>;
                            };
                        },
                    >;
                    Multisig: Enum<
                        {
                            MultisigApproval: {
                                approving: SS58String;
                                call_hash: FixedSizeBinary<32>;
                                multisig: SS58String;
                                timepoint: { height: number; index: number };
                            };
                            MultisigCancelled: {
                                call_hash: FixedSizeBinary<32>;
                                cancelling: SS58String;
                                multisig: SS58String;
                                timepoint: { height: number; index: number };
                            };
                            MultisigExecuted: {
                                approving: SS58String;
                                call_hash: FixedSizeBinary<32>;
                                multisig: SS58String;
                                result: ResultPayload<undefined, Enum<(...)>>;
                                timepoint: { height: number; index: number };
                            };
                            NewMultisig: {
                                approving: SS58String;
                                call_hash: FixedSizeBinary<32>;
                                multisig: SS58String;
                            };
                        },
                    >;
                    NftFractionalization: Enum<
                        {
                            NftFractionalized: {
                                asset: number;
                                beneficiary: SS58String;
                                fractions: bigint;
                                nft: number;
                                nft_collection: number;
                            };
                            NftUnified: {
                                asset: number;
                                beneficiary: SS58String;
                                nft: number;
                                nft_collection: number;
                            };
                        },
                    >;
                    Nfts: Enum<
                        {
                            AllApprovalsCancelled: {
                                collection: number;
                                item: number;
                                owner: SS58String;
                            };
                            ApprovalCancelled: {
                                collection: number;
                                delegate: SS58String;
                                item: number;
                                owner: SS58String;
                            };
                            AttributeCleared: {
                                collection: number;
                                key: Binary;
                                maybe_item?: ...;
                                namespace: Enum<
                                    {
                                        Account: ...;
                                        CollectionOwner: ...;
                                        ItemOwner: ...;
                                        Pallet: ...;
                                    },
                                >;
                            };
                            AttributeSet: {
                                collection: number;
                                key: Binary;
                                maybe_item?: ...;
                                namespace: Enum<
                                    {
                                        Account: ...;
                                        CollectionOwner: ...;
                                        ItemOwner: ...;
                                        Pallet: ...;
                                    },
                                >;
                                value: Binary;
                            };
                            Burned: { collection: number; item: number; owner: SS58String };
                            CollectionConfigChanged: { collection: number };
                            CollectionLocked: { collection: number };
                            CollectionMaxSupplySet: { collection: number; max_supply: number };
                            CollectionMetadataCleared: { collection: number };
                            CollectionMetadataSet: { collection: number; data: Binary };
                            CollectionMintSettingsUpdated: { collection: number };
                            Created: {
                                collection: number;
                                creator: SS58String;
                                owner: SS58String;
                            };
                            Destroyed: { collection: number };
                            ForceCreated: { collection: number; owner: SS58String };
                            Issued: { collection: number; item: number; owner: SS58String };
                            ItemAttributesApprovalAdded: {
                                collection: number;
                                delegate: SS58String;
                                item: number;
                            };
                            ItemAttributesApprovalRemoved: {
                                collection: number;
                                delegate: SS58String;
                                item: number;
                            };
                            ItemBought: {
                                buyer: SS58String;
                                collection: number;
                                item: number;
                                price: bigint;
                                seller: SS58String;
                            };
                            ItemMetadataCleared: { collection: number; item: number };
                            ItemMetadataSet: { collection: number; data: Binary; item: number };
                            ItemPriceRemoved: { collection: number; item: number };
                            ItemPriceSet: {
                                collection: number;
                                item: number;
                                price: bigint;
                                whitelisted_buyer?: ...;
                            };
                            ItemPropertiesLocked: {
                                collection: number;
                                item: number;
                                lock_attributes: boolean;
                                lock_metadata: boolean;
                            };
                            ItemTransferLocked: { collection: number; item: number };
                            ItemTransferUnlocked: { collection: number; item: number };
                            NextCollectionIdIncremented: { next_id?: ... };
                            OwnerChanged: { collection: number; new_owner: SS58String };
                            OwnershipAcceptanceChanged: {
                                maybe_collection?: ...;
                                who: SS58String;
                            };
                            PalletAttributeSet: {
                                attribute: Enum<{ TransferDisabled: ...; UsedToClaim: ... }>;
                                collection: number;
                                item?: ...;
                                value: Binary;
                            };
                            PreSignedAttributesSet: {
                                collection: number;
                                item: number;
                                namespace: Enum<
                                    {
                                        Account: ...;
                                        CollectionOwner: ...;
                                        ItemOwner: ...;
                                        Pallet: ...;
                                    },
                                >;
                            };
                            Redeposited: { collection: number; successful_items: number[] };
                            SwapCancelled: {
                                deadline: number;
                                desired_collection: number;
                                desired_item?: ...;
                                offered_collection: number;
                                offered_item: number;
                                price?: ...;
                            };
                            SwapClaimed: {
                                deadline: number;
                                price?: ...;
                                received_collection: number;
                                received_item: number;
                                received_item_owner: SS58String;
                                sent_collection: number;
                                sent_item: number;
                                sent_item_owner: SS58String;
                            };
                            SwapCreated: {
                                deadline: number;
                                desired_collection: number;
                                desired_item?: ...;
                                offered_collection: number;
                                offered_item: number;
                                price?: ...;
                            };
                            TeamChanged: {
                                admin?: ...;
                                collection: number;
                                freezer?: ...;
                                issuer?: ...;
                            };
                            TipSent: {
                                amount: bigint;
                                collection: number;
                                item: number;
                                receiver: SS58String;
                                sender: SS58String;
                            };
                            TransferApproved: {
                                collection: number;
                                deadline?: ...;
                                delegate: SS58String;
                                item: number;
                                owner: SS58String;
                            };
                            Transferred: {
                                collection: number;
                                from: SS58String;
                                item: number;
                                to: SS58String;
                            };
                        },
                    >;
                    ParachainSystem: Enum<
                        {
                            DownwardMessagesProcessed: {
                                dmq_head: FixedSizeBinary<32>;
                                weight_used: { proof_size: bigint; ref_time: bigint };
                            };
                            DownwardMessagesReceived: { count: number };
                            UpwardMessageSent: { message_hash?: ... };
                            ValidationFunctionApplied: { relay_chain_block_num: number };
                            ValidationFunctionDiscarded: undefined;
                            ValidationFunctionStored: undefined;
                        },
                    >;
                    PolkadotXcm: Enum<
                        {
                            AssetsClaimed: {
                                assets: Enum<{ V3: ...; V4: ...; V5: ... }>;
                                hash: FixedSizeBinary<32>;
                                origin: { interior: Enum<(...)>; parents: number };
                            };
                            AssetsTrapped: {
                                assets: Enum<{ V3: ...; V4: ...; V5: ... }>;
                                hash: FixedSizeBinary<32>;
                                origin: { interior: Enum<(...)>; parents: number };
                            };
                            Attempted: {
                                outcome: Enum<{ Complete: ...; Error: ...; Incomplete: ... }>;
                            };
                            FeesPaid: {
                                fees: { fun: ...; id: ... }[];
                                paying: { interior: Enum<(...)>; parents: number };
                            };
                            InvalidQuerier: {
                                expected_querier: { interior: Enum<(...)>; parents: number };
                                maybe_actual_querier?: ...;
                                origin: { interior: Enum<(...)>; parents: number };
                                query_id: bigint;
                            };
                            InvalidQuerierVersion: {
                                origin: { interior: Enum<(...)>; parents: number };
                                query_id: bigint;
                            };
                            InvalidResponder: {
                                expected_location?: ...;
                                origin: { interior: Enum<(...)>; parents: number };
                                query_id: bigint;
                            };
                            InvalidResponderVersion: {
                                origin: { interior: Enum<(...)>; parents: number };
                                query_id: bigint;
                            };
                            Notified: {
                                call_index: number;
                                pallet_index: number;
                                query_id: bigint;
                            };
                            NotifyDecodeFailed: {
                                call_index: number;
                                pallet_index: number;
                                query_id: bigint;
                            };
                            NotifyDispatchError: {
                                call_index: number;
                                pallet_index: number;
                                query_id: bigint;
                            };
                            NotifyOverweight: {
                                actual_weight: { proof_size: bigint; ref_time: bigint };
                                call_index: number;
                                max_budgeted_weight: { proof_size: bigint; ref_time: bigint };
                                pallet_index: number;
                                query_id: bigint;
                            };
                            NotifyTargetMigrationFail: {
                                location: Enum<{ V3: ...; V4: ...; V5: ... }>;
                                query_id: bigint;
                            };
                            NotifyTargetSendFail: {
                                error: Enum<
                                    {
                                        AssetNotFound: ...;
                                        BadOrigin: ...;
                                        Barrier: ...;
                                        DestinationUnsupported: ...;
                                        ExceedsMaxMessageSize: ...;
                                        ExceedsStackLimit: ...;
                                        ExpectationFalse: ...;
                                        ExportError: ...;
                                        FailedToDecode: ...;
                                        FailedToTransactAsset: ...;
                                        FeesNotMet: ...;
                                        HoldingWouldOverflow: ...;
                                        InvalidLocation: ...;
                                        LocationCannotHold: ...;
                                        LocationFull: ...;
                                        LocationNotInvertible: ...;
                                        LockError: ...;
                                        MaxWeightInvalid: ...;
                                        NameMismatch: ...;
                                        NoDeal: ...;
                                        NoPermission: ...;
                                        NotDepositable: ...;
                                        NotHoldingFees: ...;
                                        NotWithdrawable: ...;
                                        Overflow: ...;
                                        PalletNotFound: ...;
                                        ReanchorFailed: ...;
                                        TooExpensive: ...;
                                        TooManyAssets: ...;
                                        Transport: ...;
                                        Trap: ...;
                                        Unanchored: ...;
                                        UnhandledXcmVersion: ...;
                                        Unimplemented: ...;
                                        UnknownClaim: ...;
                                        Unroutable: ...;
                                        UntrustedReserveLocation: ...;
                                        UntrustedTeleportLocation: ...;
                                        VersionIncompatible: ...;
                                        WeightLimitReached: ...;
                                        WeightNotComputable: ...;
                                    },
                                >;
                                location: { interior: Enum<(...)>; parents: number };
                                query_id: bigint;
                            };
                            ResponseReady: {
                                query_id: bigint;
                                response: Enum<
                                    {
                                        Assets: ...;
                                        DispatchResult: ...;
                                        ExecutionResult?: ...;
                                        Null: ...;
                                        PalletsInfo: ...;
                                        Version: ...;
                                    },
                                >;
                            };
                            ResponseTaken: { query_id: bigint };
                            Sent: {
                                destination: { interior: Enum<(...)>; parents: number };
                                message: Enum<(...)>[];
                                message_id: FixedSizeBinary<32>;
                                origin: { interior: Enum<(...)>; parents: number };
                            };
                            SupportedVersionChanged: {
                                location: { interior: Enum<(...)>; parents: number };
                                version: number;
                            };
                            UnexpectedResponse: {
                                origin: { interior: Enum<(...)>; parents: number };
                                query_id: bigint;
                            };
                            VersionChangeNotified: {
                                cost: { fun: ...; id: ... }[];
                                destination: { interior: Enum<(...)>; parents: number };
                                message_id: FixedSizeBinary<32>;
                                result: number;
                            };
                            VersionMigrationFinished: { version: number };
                            VersionNotifyRequested: {
                                cost: { fun: ...; id: ... }[];
                                destination: { interior: Enum<(...)>; parents: number };
                                message_id: FixedSizeBinary<32>;
                            };
                            VersionNotifyStarted: {
                                cost: { fun: ...; id: ... }[];
                                destination: { interior: Enum<(...)>; parents: number };
                                message_id: FixedSizeBinary<32>;
                            };
                            VersionNotifyUnrequested: {
                                cost: { fun: ...; id: ... }[];
                                destination: { interior: Enum<(...)>; parents: number };
                                message_id: FixedSizeBinary<32>;
                            };
                        },
                    >;
                    PoolAssets: Enum<
                        {
                            AccountsDestroyed: {
                                accounts_destroyed: number;
                                accounts_remaining: number;
                                asset_id: number;
                            };
                            ApprovalCancelled: {
                                asset_id: number;
                                delegate: SS58String;
                                owner: SS58String;
                            };
                            ApprovalsDestroyed: {
                                approvals_destroyed: number;
                                approvals_remaining: number;
                                asset_id: number;
                            };
                            ApprovedTransfer: {
                                amount: bigint;
                                asset_id: number;
                                delegate: SS58String;
                                source: SS58String;
                            };
                            AssetFrozen: { asset_id: number };
                            AssetMinBalanceChanged: { asset_id: number; new_min_balance: bigint };
                            AssetStatusChanged: { asset_id: number };
                            AssetThawed: { asset_id: number };
                            Blocked: { asset_id: number; who: SS58String };
                            Burned: { asset_id: number; balance: bigint; owner: SS58String };
                            Created: { asset_id: number; creator: SS58String; owner: SS58String };
                            Deposited: { amount: bigint; asset_id: number; who: SS58String };
                            Destroyed: { asset_id: number };
                            DestructionStarted: { asset_id: number };
                            ForceCreated: { asset_id: number; owner: SS58String };
                            Frozen: { asset_id: number; who: SS58String };
                            Issued: { amount: bigint; asset_id: number; owner: SS58String };
                            MetadataCleared: { asset_id: number };
                            MetadataSet: {
                                asset_id: number;
                                decimals: number;
                                is_frozen: boolean;
                                name: Binary;
                                symbol: Binary;
                            };
                            OwnerChanged: { asset_id: number; owner: SS58String };
                            TeamChanged: {
                                admin: SS58String;
                                asset_id: number;
                                freezer: SS58String;
                                issuer: SS58String;
                            };
                            Thawed: { asset_id: number; who: SS58String };
                            Touched: { asset_id: number; depositor: SS58String; who: SS58String };
                            Transferred: {
                                amount: bigint;
                                asset_id: number;
                                from: SS58String;
                                to: SS58String;
                            };
                            TransferredApproved: {
                                amount: bigint;
                                asset_id: number;
                                delegate: SS58String;
                                destination: SS58String;
                                owner: SS58String;
                            };
                            Withdrawn: { amount: bigint; asset_id: number; who: SS58String };
                        },
                    >;
                    PoolAssetsFreezer: Enum<
                        {
                            Frozen: { amount: bigint; asset_id: number; who: SS58String };
                            Thawed: { amount: bigint; asset_id: number; who: SS58String };
                        },
                    >;
                    Proxy: Enum<
                        {
                            Announced: {
                                call_hash: FixedSizeBinary<32>;
                                proxy: SS58String;
                                real: SS58String;
                            };
                            ProxyAdded: {
                                delay: number;
                                delegatee: SS58String;
                                delegator: SS58String;
                                proxy_type: Enum<
                                    {
                                        Any: ...;
                                        AssetManager: ...;
                                        AssetOwner: ...;
                                        Assets: ...;
                                        CancelProxy: ...;
                                        Collator: ...;
                                        NonTransfer: ...;
                                    },
                                >;
                            };
                            ProxyExecuted: { result: ResultPayload<undefined, Enum<(...)>> };
                            ProxyRemoved: {
                                delay: number;
                                delegatee: SS58String;
                                delegator: SS58String;
                                proxy_type: Enum<
                                    {
                                        Any: ...;
                                        AssetManager: ...;
                                        AssetOwner: ...;
                                        Assets: ...;
                                        CancelProxy: ...;
                                        Collator: ...;
                                        NonTransfer: ...;
                                    },
                                >;
                            };
                            PureCreated: {
                                disambiguation_index: number;
                                proxy_type: Enum<
                                    {
                                        Any: ...;
                                        AssetManager: ...;
                                        AssetOwner: ...;
                                        Assets: ...;
                                        CancelProxy: ...;
                                        Collator: ...;
                                        NonTransfer: ...;
                                    },
                                >;
                                pure: SS58String;
                                who: SS58String;
                            };
                        },
                    >;
                    Revive: Enum<
                        {
                            ContractEmitted: {
                                contract: FixedSizeBinary<20>;
                                data: Binary;
                                topics: FixedSizeBinary<(...)>[];
                            };
                        },
                    >;
                    Session: SessionEvent;
                    StateTrieMigration: Enum<
                        {
                            AutoMigrationFinished: undefined;
                            Halted: {
                                error: Enum<
                                    {
                                        BadChildRoot: ...;
                                        BadWitness: ...;
                                        KeyTooLong: ...;
                                        MaxSignedLimits: ...;
                                        NotEnoughFunds: ...;
                                        SignedMigrationNotAllowed: ...;
                                    },
                                >;
                            };
                            Migrated: {
                                child: number;
                                compute: Enum<{ Auto: ...; Signed: ... }>;
                                top: number;
                            };
                            Slashed: { amount: bigint; who: SS58String };
                        },
                    >;
                    System: Enum<
                        {
                            CodeUpdated: undefined;
                            ExtrinsicFailed: {
                                dispatch_error: Enum<
                                    {
                                        Arithmetic: ...;
                                        BadOrigin: ...;
                                        CannotLookup: ...;
                                        ConsumerRemaining: ...;
                                        Corruption: ...;
                                        Exhausted: ...;
                                        Module: ...;
                                        NoProviders: ...;
                                        Other: ...;
                                        RootNotAllowed: ...;
                                        Token: ...;
                                        TooManyConsumers: ...;
                                        Transactional: ...;
                                        Trie: ...;
                                        Unavailable: ...;
                                    },
                                >;
                                dispatch_info: {
                                    class: DispatchClass;
                                    pays_fee: Enum<(...)>;
                                    weight: { proof_size: ...; ref_time: ... };
                                };
                            };
                            ExtrinsicSuccess: {
                                dispatch_info: {
                                    class: DispatchClass;
                                    pays_fee: Enum<(...)>;
                                    weight: { proof_size: ...; ref_time: ... };
                                };
                            };
                            KilledAccount: { account: SS58String };
                            NewAccount: { account: SS58String };
                            Remarked: { hash: FixedSizeBinary<32>; sender: SS58String };
                            UpgradeAuthorized: {
                                check_version: boolean;
                                code_hash: FixedSizeBinary<32>;
                            };
                        },
                    >;
                    ToRococoXcmRouter: Enum<
                        {
                            DeliveryFeeFactorDecreased: { new_value: bigint };
                            DeliveryFeeFactorIncreased: { new_value: bigint };
                        },
                    >;
                    TransactionPayment: TransactionPaymentEvent;
                    Uniques: Enum<
                        {
                            ApprovalCancelled: {
                                collection: number;
                                delegate: SS58String;
                                item: number;
                                owner: SS58String;
                            };
                            ApprovedTransfer: {
                                collection: number;
                                delegate: SS58String;
                                item: number;
                                owner: SS58String;
                            };
                            AttributeCleared: {
                                collection: number;
                                key: Binary;
                                maybe_item?: ...;
                            };
                            AttributeSet: {
                                collection: number;
                                key: Binary;
                                maybe_item?: ...;
                                value: Binary;
                            };
                            Burned: { collection: number; item: number; owner: SS58String };
                            CollectionFrozen: { collection: number };
                            CollectionMaxSupplySet: { collection: number; max_supply: number };
                            CollectionMetadataCleared: { collection: number };
                            CollectionMetadataSet: {
                                collection: number;
                                data: Binary;
                                is_frozen: boolean;
                            };
                            CollectionThawed: { collection: number };
                            Created: {
                                collection: number;
                                creator: SS58String;
                                owner: SS58String;
                            };
                            Destroyed: { collection: number };
                            ForceCreated: { collection: number; owner: SS58String };
                            Frozen: { collection: number; item: number };
                            Issued: { collection: number; item: number; owner: SS58String };
                            ItemBought: {
                                buyer: SS58String;
                                collection: number;
                                item: number;
                                price: bigint;
                                seller: SS58String;
                            };
                            ItemPriceRemoved: { collection: number; item: number };
                            ItemPriceSet: {
                                collection: number;
                                item: number;
                                price: bigint;
                                whitelisted_buyer?: ...;
                            };
                            ItemStatusChanged: { collection: number };
                            MetadataCleared: { collection: number; item: number };
                            MetadataSet: {
                                collection: number;
                                data: Binary;
                                is_frozen: boolean;
                                item: number;
                            };
                            OwnerChanged: { collection: number; new_owner: SS58String };
                            OwnershipAcceptanceChanged: {
                                maybe_collection?: ...;
                                who: SS58String;
                            };
                            Redeposited: { collection: number; successful_items: number[] };
                            TeamChanged: {
                                admin: SS58String;
                                collection: number;
                                freezer: SS58String;
                                issuer: SS58String;
                            };
                            Thawed: { collection: number; item: number };
                            Transferred: {
                                collection: number;
                                from: SS58String;
                                item: number;
                                to: SS58String;
                            };
                        },
                    >;
                    Utility: Enum<
                        {
                            BatchCompleted: undefined;
                            BatchCompletedWithErrors: undefined;
                            BatchInterrupted: {
                                error: Enum<
                                    {
                                        Arithmetic: ...;
                                        BadOrigin: ...;
                                        CannotLookup: ...;
                                        ConsumerRemaining: ...;
                                        Corruption: ...;
                                        Exhausted: ...;
                                        Module: ...;
                                        NoProviders: ...;
                                        Other: ...;
                                        RootNotAllowed: ...;
                                        Token: ...;
                                        TooManyConsumers: ...;
                                        Transactional: ...;
                                        Trie: ...;
                                        Unavailable: ...;
                                    },
                                >;
                                index: number;
                            };
                            DispatchedAs: { result: ResultPayload<undefined, Enum<(...)>> };
                            ItemCompleted: undefined;
                            ItemFailed: {
                                error: Enum<
                                    {
                                        Arithmetic: ...;
                                        BadOrigin: ...;
                                        CannotLookup: ...;
                                        ConsumerRemaining: ...;
                                        Corruption: ...;
                                        Exhausted: ...;
                                        Module: ...;
                                        NoProviders: ...;
                                        Other: ...;
                                        RootNotAllowed: ...;
                                        Token: ...;
                                        TooManyConsumers: ...;
                                        Transactional: ...;
                                        Trie: ...;
                                        Unavailable: ...;
                                    },
                                >;
                            };
                        },
                    >;
                    XcmpQueue: Enum<
                        { XcmpMessageSent: { message_hash: FixedSizeBinary<32> } },
                    >;
                },
            >[];
            execution_result: ResultPayload<
                {
                    actual_weight?: { proof_size: bigint; ref_time: bigint };
                    pays_fee: Enum<{ No: undefined; Yes: undefined }>;
                },
                {
                    error: Enum<
                        {
                            Arithmetic: ArithmeticError;
                            BadOrigin: undefined;
                            CannotLookup: undefined;
                            ConsumerRemaining: undefined;
                            Corruption: undefined;
                            Exhausted: undefined;
                            Module: Enum<
                                {
                                    AssetConversion: Enum<
                                        {
                                            AmountOneLessThanMinimal: ...;
                                            AmountOutTooHigh: ...;
                                            AmountTwoLessThanMinimal: ...;
                                            AssetOneDepositDidNotMeetMinimum: ...;
                                            AssetOneWithdrawalDidNotMeetMinimum: ...;
                                            AssetTwoDepositDidNotMeetMinimum: ...;
                                            AssetTwoWithdrawalDidNotMeetMinimum: ...;
                                            BelowMinimum: ...;
                                            IncorrectPoolAssetId: ...;
                                            InsufficientLiquidityMinted: ...;
                                            InvalidAssetPair: ...;
                                            InvalidPath: ...;
                                            NonUniquePath: ...;
                                            OptimalAmountLessThanDesired: ...;
                                            Overflow: ...;
                                            PoolExists: ...;
                                            PoolNotFound: ...;
                                            ProvidedMaximumNotSufficientForSwap: ...;
                                            ProvidedMinimumNotSufficientForSwap: ...;
                                            ReserveLeftLessThanMinimal: ...;
                                            WrongDesiredAmount: ...;
                                            ZeroAmount: ...;
                                            ZeroLiquidity: ...;
                                        },
                                    >;
                                    AssetConversionMigration: Enum<
                                        {
                                            InvalidAssetPair: ...;
                                            PartialTransfer: ...;
                                            PoolNotFound: ...;
                                            ZeroBalance: ...;
                                        },
                                    >;
                                    AssetRewards: Enum<
                                        {
                                            BlockNumberConversionError: ...;
                                            ExpiryBlockMustBeInTheFuture: ...;
                                            ExpiryCut: ...;
                                            InsufficientFunds: ...;
                                            NonEmptyPool: ...;
                                            NonExistentAsset: ...;
                                            NonExistentPool: ...;
                                            NonExistentStaker: ...;
                                            NotEnoughTokens: ...;
                                            RewardRateCut: ...;
                                        },
                                    >;
                                    Assets: Enum<
                                        {
                                            AlreadyExists: ...;
                                            AssetNotLive: ...;
                                            BadAssetId: ...;
                                            BadMetadata: ...;
                                            BadWitness: ...;
                                            BalanceLow: ...;
                                            CallbackFailed: ...;
                                            Frozen: ...;
                                            IncorrectStatus: ...;
                                            InUse: ...;
                                            LiveAsset: ...;
                                            MinBalanceZero: ...;
                                            NoAccount: ...;
                                            NoDeposit: ...;
                                            NoPermission: ...;
                                            NotFrozen: ...;
                                            Unapproved: ...;
                                            UnavailableConsumer: ...;
                                            Unknown: ...;
                                            WouldBurn: ...;
                                            WouldDie: ...;
                                        },
                                    >;
                                    AssetsFreezer: Enum<{ TooManyFreezes: ... }>;
                                    AssetTxPayment: undefined;
                                    Aura: undefined;
                                    AuraExt: undefined;
                                    Authorship: undefined;
                                    Balances: Enum<
                                        {
                                            DeadAccount: ...;
                                            DeltaZero: ...;
                                            ExistentialDeposit: ...;
                                            ExistingVestingSchedule: ...;
                                            Expendability: ...;
                                            InsufficientBalance: ...;
                                            IssuanceDeactivated: ...;
                                            LiquidityRestrictions: ...;
                                            TooManyFreezes: ...;
                                            TooManyHolds: ...;
                                            TooManyReserves: ...;
                                            VestingBalance: ...;
                                        },
                                    >;
                                    CollatorSelection: Enum<
                                        {
                                            AlreadyCandidate: ...;
                                            AlreadyInvulnerable: ...;
                                            DepositTooLow: ...;
                                            IdenticalDeposit: ...;
                                            InsertToCandidateListFailed: ...;
                                            InsufficientBond: ...;
                                            InvalidUnreserve: ...;
                                            NoAssociatedValidatorId: ...;
                                            NotCandidate: ...;
                                            NotInvulnerable: ...;
                                            RemoveFromCandidateListFailed: ...;
                                            TargetIsNotCandidate: ...;
                                            TooFewEligibleCollators: ...;
                                            TooManyCandidates: ...;
                                            TooManyInvulnerables: ...;
                                            UpdateCandidateListFailed: ...;
                                            ValidatorNotRegistered: ...;
                                        },
                                    >;
                                    CumulusXcm: undefined;
                                    ForeignAssets: Enum<
                                        {
                                            AlreadyExists: ...;
                                            AssetNotLive: ...;
                                            BadAssetId: ...;
                                            BadMetadata: ...;
                                            BadWitness: ...;
                                            BalanceLow: ...;
                                            CallbackFailed: ...;
                                            Frozen: ...;
                                            IncorrectStatus: ...;
                                            InUse: ...;
                                            LiveAsset: ...;
                                            MinBalanceZero: ...;
                                            NoAccount: ...;
                                            NoDeposit: ...;
                                            NoPermission: ...;
                                            NotFrozen: ...;
                                            Unapproved: ...;
                                            UnavailableConsumer: ...;
                                            Unknown: ...;
                                            WouldBurn: ...;
                                            WouldDie: ...;
                                        },
                                    >;
                                    ForeignAssetsFreezer: Enum<{ TooManyFreezes: ... }>;
                                    MessageQueue: Enum<
                                        {
                                            AlreadyProcessed: ...;
                                            InsufficientWeight: ...;
                                            NoMessage: ...;
                                            NoPage: ...;
                                            NotReapable: ...;
                                            Queued: ...;
                                            QueuePaused: ...;
                                            RecursiveDisallowed: ...;
                                            TemporarilyUnprocessable: ...;
                                        },
                                    >;
                                    Multisig: Enum<
                                        {
                                            AlreadyApproved: ...;
                                            AlreadyStored: ...;
                                            MaxWeightTooLow: ...;
                                            MinimumThreshold: ...;
                                            NoApprovalsNeeded: ...;
                                            NotFound: ...;
                                            NoTimepoint: ...;
                                            NotOwner: ...;
                                            SenderInSignatories: ...;
                                            SignatoriesOutOfOrder: ...;
                                            TooFewSignatories: ...;
                                            TooManySignatories: ...;
                                            UnexpectedTimepoint: ...;
                                            WrongTimepoint: ...;
                                        },
                                    >;
                                    NftFractionalization: Enum<
                                        {
                                            IncorrectAssetId: ...;
                                            NftNotFound: ...;
                                            NftNotFractionalized: ...;
                                            NoPermission: ...;
                                        },
                                    >;
                                    Nfts: Enum<
                                        {
                                            AlreadyClaimed: ...;
                                            AlreadyExists: ...;
                                            ApprovalExpired: ...;
                                            AttributeNotFound: ...;
                                            BadWitness: ...;
                                            BidTooLow: ...;
                                            CollectionIdInUse: ...;
                                            CollectionNotEmpty: ...;
                                            DeadlineExpired: ...;
                                            InconsistentItemConfig: ...;
                                            IncorrectData: ...;
                                            IncorrectMetadata: ...;
                                            ItemLocked: ...;
                                            ItemsNonTransferable: ...;
                                            LockedCollectionAttributes: ...;
                                            LockedCollectionMetadata: ...;
                                            LockedItemAttributes: ...;
                                            LockedItemMetadata: ...;
                                            MaxAttributesLimitReached: ...;
                                            MaxSupplyLocked: ...;
                                            MaxSupplyReached: ...;
                                            MaxSupplyTooSmall: ...;
                                            MetadataNotFound: ...;
                                            MethodDisabled: ...;
                                            MintEnded: ...;
                                            MintNotStarted: ...;
                                            NoConfig: ...;
                                            NoPermission: ...;
                                            NotDelegate: ...;
                                            NotForSale: ...;
                                            ReachedApprovalLimit: ...;
                                            RolesNotCleared: ...;
                                            Unaccepted: ...;
                                            Unapproved: ...;
                                            UnknownCollection: ...;
                                            UnknownItem: ...;
                                            UnknownSwap: ...;
                                            WitnessRequired: ...;
                                            WrongDelegate: ...;
                                            WrongDuration: ...;
                                            WrongNamespace: ...;
                                            WrongOrigin: ...;
                                            WrongOwner: ...;
                                            WrongSetting: ...;
                                            WrongSignature: ...;
                                        },
                                    >;
                                    ParachainInfo: undefined;
                                    ParachainSystem: Enum<
                                        {
                                            HostConfigurationNotAvailable: ...;
                                            NothingAuthorized: ...;
                                            NotScheduled: ...;
                                            OverlappingUpgrades: ...;
                                            ProhibitedByPolkadot: ...;
                                            TooBig: ...;
                                            Unauthorized: ...;
                                            ValidationDataNotAvailable: ...;
                                        },
                                    >;
                                    PolkadotXcm: Enum<
                                        {
                                            AccountNotSovereign: ...;
                                            AlreadySubscribed: ...;
                                            BadLocation: ...;
                                            BadVersion: ...;
                                            CannotCheckOutTeleport: ...;
                                            CannotReanchor: ...;
                                            DestinationNotInvertible: ...;
                                            Empty: ...;
                                            FeesNotMet: ...;
                                            Filtered: ...;
                                            InUse: ...;
                                            InvalidAssetUnknownReserve: ...;
                                            InvalidAssetUnsupportedReserve: ...;
                                            InvalidOrigin: ...;
                                            LocalExecutionIncomplete: ...;
                                            LockNotFound: ...;
                                            LowBalance: ...;
                                            NoSubscription: ...;
                                            SendFailure: ...;
                                            TooManyAssets: ...;
                                            TooManyLocks: ...;
                                            TooManyReserves: ...;
                                            Unreachable: ...;
                                            UnweighableMessage: ...;
                                        },
                                    >;
                                    PoolAssets: Enum<
                                        {
                                            AlreadyExists: ...;
                                            AssetNotLive: ...;
                                            BadAssetId: ...;
                                            BadMetadata: ...;
                                            BadWitness: ...;
                                            BalanceLow: ...;
                                            CallbackFailed: ...;
                                            Frozen: ...;
                                            IncorrectStatus: ...;
                                            InUse: ...;
                                            LiveAsset: ...;
                                            MinBalanceZero: ...;
                                            NoAccount: ...;
                                            NoDeposit: ...;
                                            NoPermission: ...;
                                            NotFrozen: ...;
                                            Unapproved: ...;
                                            UnavailableConsumer: ...;
                                            Unknown: ...;
                                            WouldBurn: ...;
                                            WouldDie: ...;
                                        },
                                    >;
                                    PoolAssetsFreezer: Enum<{ TooManyFreezes: ... }>;
                                    Proxy: Enum<
                                        {
                                            Duplicate: ...;
                                            NoPermission: ...;
                                            NoSelfProxy: ...;
                                            NotFound: ...;
                                            NotProxy: ...;
                                            TooMany: ...;
                                            Unannounced: ...;
                                            Unproxyable: ...;
                                        },
                                    >;
                                    Revive: Enum<
                                        {
                                            AccountAlreadyMapped: ...;
                                            AccountUnmapped: ...;
                                            BalanceConversionFailed: ...;
                                            BasicBlockTooLarge: ...;
                                            BlobTooLarge: ...;
                                            CannotAddSelfAsDelegateDependency: ...;
                                            CodeInfoNotFound: ...;
                                            CodeInUse: ...;
                                            CodeNotFound: ...;
                                            CodeRejected: ...;
                                            ContractNotFound: ...;
                                            ContractReverted: ...;
                                            ContractTrapped: ...;
                                            DecimalPrecisionLoss: ...;
                                            DecodingFailed: ...;
                                            DelegateDependencyAlreadyExists: ...;
                                            DelegateDependencyNotFound: ...;
                                            DuplicateContract: ...;
                                            ExecutionFailed: ...;
                                            InputForwarded: ...;
                                            InvalidCallFlags: ...;
                                            InvalidGenericTransaction: ...;
                                            InvalidImmutableAccess: ...;
                                            InvalidInstruction: ...;
                                            InvalidSchedule: ...;
                                            InvalidStorageFlags: ...;
                                            InvalidSyscall: ...;
                                            MaxCallDepthReached: ...;
                                            MaxDelegateDependenciesReached: ...;
                                            NoChainExtension: ...;
                                            OutOfBounds: ...;
                                            OutOfGas: ...;
                                            OutOfTransientStorage: ...;
                                            ReenteredPallet: ...;
                                            ReentranceDenied: ...;
                                            StateChangeDenied: ...;
                                            StaticMemoryTooLarge: ...;
                                            StorageDepositLimitExhausted: ...;
                                            StorageDepositNotEnoughFunds: ...;
                                            TerminatedInConstructor: ...;
                                            TerminatedWhileReentrant: ...;
                                            TooManyTopics: ...;
                                            TransferFailed: ...;
                                            ValueTooLarge: ...;
                                            XCMDecodeFailed: ...;
                                        },
                                    >;
                                    Session: Enum<
                                        {
                                            DuplicatedKey: ...;
                                            InvalidProof: ...;
                                            NoAccount: ...;
                                            NoAssociatedValidatorId: ...;
                                            NoKeys: ...;
                                        },
                                    >;
                                    StateTrieMigration: Enum<
                                        {
                                            BadChildRoot: ...;
                                            BadWitness: ...;
                                            KeyTooLong: ...;
                                            MaxSignedLimits: ...;
                                            NotEnoughFunds: ...;
                                            SignedMigrationNotAllowed: ...;
                                        },
                                    >;
                                    System: Enum<
                                        {
                                            CallFiltered: ...;
                                            FailedToExtractRuntimeVersion: ...;
                                            InvalidSpecName: ...;
                                            MultiBlockMigrationsOngoing: ...;
                                            NonDefaultComposite: ...;
                                            NonZeroRefCount: ...;
                                            NothingAuthorized: ...;
                                            SpecVersionNeedsToIncrease: ...;
                                            Unauthorized: ...;
                                        },
                                    >;
                                    Timestamp: undefined;
                                    ToRococoXcmRouter: undefined;
                                    TransactionPayment: undefined;
                                    Uniques: Enum<
                                        {
                                            AlreadyExists: ...;
                                            BadWitness: ...;
                                            BidTooLow: ...;
                                            Frozen: ...;
                                            InUse: ...;
                                            Locked: ...;
                                            MaxSupplyAlreadySet: ...;
                                            MaxSupplyReached: ...;
                                            MaxSupplyTooSmall: ...;
                                            NoDelegate: ...;
                                            NoPermission: ...;
                                            NotForSale: ...;
                                            Unaccepted: ...;
                                            Unapproved: ...;
                                            UnknownCollection: ...;
                                            UnknownItem: ...;
                                            WrongDelegate: ...;
                                            WrongOwner: ...;
                                        },
                                    >;
                                    Utility: Enum<{ TooManyCalls: ... }>;
                                    WeightReclaim: undefined;
                                    XcmpQueue: Enum<
                                        {
                                            AlreadyResumed: ...;
                                            AlreadySuspended: ...;
                                            BadQueueConfig: ...;
                                            TooBig: ...;
                                            TooManyActiveOutboundChannels: ...;
                                        },
                                    >;
                                },
                            >;
                            NoProviders: undefined;
                            Other: undefined;
                            RootNotAllowed: undefined;
                            Token: TokenError;
                            TooManyConsumers: undefined;
                            Transactional: TransactionalError;
                            Trie: Enum<
                                {
                                    DecodeError: undefined;
                                    DecoderError: undefined;
                                    DuplicateKey: undefined;
                                    ExtraneousHashReference: undefined;
                                    ExtraneousNode: undefined;
                                    ExtraneousValue: undefined;
                                    IncompleteDatabase: undefined;
                                    IncompleteProof: undefined;
                                    InvalidChildReference: undefined;
                                    InvalidHash: undefined;
                                    InvalidStateRoot: undefined;
                                    RootMismatch: undefined;
                                    ValueAtIncompleteKey: undefined;
                                    ValueMismatch: undefined;
                                },
                            >;
                            Unavailable: undefined;
                        },
                    >;
                    post_info: {
                        actual_weight?: { proof_size: bigint; ref_time: bigint };
                        pays_fee: Enum<{ No: undefined; Yes: undefined }>;
                    };
                },
            >;
            forwarded_xcms: [
                Enum<
                    {
                        V3: { interior: XcmV3Junctions; parents: number };
                        V4: { interior: XcmV3Junctions; parents: number };
                        V5: {
                            interior: Enum<
                                {
                                    Here: undefined;
                                    X1: Enum<(...)>;
                                    X2: FixedSizeArray<(...), (...)>;
                                    X3: FixedSizeArray<(...), (...)>;
                                    X4: FixedSizeArray<(...), (...)>;
                                    X5: FixedSizeArray<(...), (...)>;
                                    X6: FixedSizeArray<(...), (...)>;
                                    X7: FixedSizeArray<(...), (...)>;
                                    X8: FixedSizeArray<(...), (...)>;
                                },
                            >;
                            parents: number;
                        };
                    },
                >,
                Enum<
                    {
                        V3: XcmV3Instruction[];
                        V4: XcmV4Instruction[];
                        V5: Enum<
                            {
                                AliasOrigin: ...;
                                BurnAsset: ...;
                                BuyExecution: ...;
                                ClaimAsset: ...;
                                ClearError: ...;
                                ClearOrigin: ...;
                                ClearTopic: ...;
                                ClearTransactStatus: ...;
                                DepositAsset: ...;
                                DepositReserveAsset: ...;
                                DescendOrigin: ...;
                                ExchangeAsset: ...;
                                ExecuteWithOrigin: ...;
                                ExpectAsset: ...;
                                ExpectError?: ...;
                                ExpectOrigin?: ...;
                                ExpectPallet: ...;
                                ExpectTransactStatus: ...;
                                ExportMessage: ...;
                                HrmpChannelAccepted: ...;
                                HrmpChannelClosing: ...;
                                HrmpNewChannelOpenRequest: ...;
                                InitiateReserveWithdraw: ...;
                                InitiateTeleport: ...;
                                InitiateTransfer: ...;
                                LockAsset: ...;
                                NoteUnlockable: ...;
                                PayFees: ...;
                                QueryPallet: ...;
                                QueryResponse: ...;
                                ReceiveTeleportedAsset: ...;
                                RefundSurplus: ...;
                                ReportError: ...;
                                ReportHolding: ...;
                                ReportTransactStatus: ...;
                                RequestUnlock: ...;
                                ReserveAssetDeposited: ...;
                                SetAppendix: ...;
                                SetErrorHandler: ...;
                                SetFeesMode: ...;
                                SetHints: ...;
                                SetTopic: ...;
                                SubscribeVersion: ...;
                                Transact: ...;
                                TransferAsset: ...;
                                TransferReserveAsset: ...;
                                Trap: ...;
                                UniversalOrigin: ...;
                                UnlockAsset: ...;
                                UnpaidExecution: ...;
                                UnsubscribeVersion: ...;
                                WithdrawAsset: ...;
                            },
                        >[];
                    },
                >[],
            ][];
            local_xcm?: Enum<
                {
                    V3: XcmV3Instruction[];
                    V4: XcmV4Instruction[];
                    V5: Enum<
                        {
                            AliasOrigin: { interior: ...; parents: ... };
                            BurnAsset: (...)[];
                            BuyExecution: { fees: ...; weight_limit: ... };
                            ClaimAsset: { assets: ...; ticket: ... };
                            ClearError: undefined;
                            ClearOrigin: undefined;
                            ClearTopic: undefined;
                            ClearTransactStatus: undefined;
                            DepositAsset: { assets: ...; beneficiary: ... };
                            DepositReserveAsset: { assets: ...; dest: ...; xcm: ... };
                            DescendOrigin: Enum<(...)>;
                            ExchangeAsset: { give: ...; maximal: ...; want: ... };
                            ExecuteWithOrigin: { descendant_origin?: ...; xcm: ... };
                            ExpectAsset: (...)[];
                            ExpectError?: (...) | (...);
                            ExpectOrigin?: (...) | (...);
                            ExpectPallet: {
                                crate_major: ...;
                                index: ...;
                                min_crate_minor: ...;
                                module_name: ...;
                                name: ...;
                            };
                            ExpectTransactStatus: XcmV3MaybeErrorCode;
                            ExportMessage: { destination: ...; network: ...; xcm: ... };
                            HrmpChannelAccepted: { recipient: ... };
                            HrmpChannelClosing: { initiator: ...; recipient: ...; sender: ... };
                            HrmpNewChannelOpenRequest: {
                                max_capacity: ...;
                                max_message_size: ...;
                                sender: ...;
                            };
                            InitiateReserveWithdraw: { assets: ...; reserve: ...; xcm: ... };
                            InitiateTeleport: { assets: ...; dest: ...; xcm: ... };
                            InitiateTransfer: {
                                assets: ...;
                                destination: ...;
                                preserve_origin: ...;
                                remote_fees?: ...;
                                remote_xcm: ...;
                            };
                            LockAsset: { asset: ...; unlocker: ... };
                            NoteUnlockable: { asset: ...; owner: ... };
                            PayFees: { asset: ... };
                            QueryPallet: { module_name: ...; response_info: ... };
                            QueryResponse: {
                                max_weight: ...;
                                querier?: ...;
                                query_id: ...;
                                response: ...;
                            };
                            ReceiveTeleportedAsset: (...)[];
                            RefundSurplus: undefined;
                            ReportError: { destination: ...; max_weight: ...; query_id: ... };
                            ReportHolding: { assets: ...; response_info: ... };
                            ReportTransactStatus: {
                                destination: ...;
                                max_weight: ...;
                                query_id: ...;
                            };
                            RequestUnlock: { asset: ...; locker: ... };
                            ReserveAssetDeposited: (...)[];
                            SetAppendix: __Circular;
                            SetErrorHandler: __Circular;
                            SetFeesMode: { jit_withdraw: ... };
                            SetHints: { hints: ... };
                            SetTopic: FixedSizeBinary<(...)>;
                            SubscribeVersion: { max_response_weight: ...; query_id: ... };
                            Transact: { call: ...; fallback_max_weight?: ...; origin_kind: ... };
                            TransferAsset: { assets: ...; beneficiary: ... };
                            TransferReserveAsset: { assets: ...; dest: ...; xcm: ... };
                            Trap: bigint;
                            UniversalOrigin: Enum<(...)>;
                            UnlockAsset: { asset: ...; target: ... };
                            UnpaidExecution: { check_origin?: ...; weight_limit: ... };
                            UnsubscribeVersion: undefined;
                            WithdrawAsset: (...)[];
                        },
                    >[];
                },
            >;
        },
        Enum<{ Unimplemented: undefined; VersionedConversionFailed: undefined }>,
    >,
>