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;
            };
        }>;
        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<{
            Called: {
                caller: Enum<{
                    Root: ...;
                    Signed: ...;
                }>;
                contract: FixedSizeBinary<20>;
            };
            CodeRemoved: {
                code_hash: FixedSizeBinary<32>;
                deposit_released: bigint;
                remover: FixedSizeBinary<20>;
            };
            CodeStored: {
                code_hash: FixedSizeBinary<32>;
                deposit_held: bigint;
                uploader: FixedSizeBinary<20>;
            };
            ContractCodeUpdated: {
                contract: FixedSizeBinary<20>;
                new_code_hash: FixedSizeBinary<32>;
                old_code_hash: FixedSizeBinary<32>;
            };
            ContractEmitted: {
                contract: FixedSizeBinary<20>;
                data: Binary;
                topics: FixedSizeBinary<(...)>[];
            };
            DelegateCalled: {
                code_hash: FixedSizeBinary<32>;
                contract: FixedSizeBinary<20>;
            };
            Instantiated: {
                contract: FixedSizeBinary<20>;
                deployer: FixedSizeBinary<20>;
            };
            StorageDepositTransferredAndHeld: {
                amount: bigint;
                from: FixedSizeBinary<20>;
                to: FixedSizeBinary<20>;
            };
            StorageDepositTransferredAndReleased: {
                amount: bigint;
                from: FixedSizeBinary<20>;
                to: FixedSizeBinary<20>;
            };
            Terminated: {
                beneficiary: FixedSizeBinary<20>;
                contract: FixedSizeBinary<20>;
            };
        }>;
        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: ...;
                }>;
                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: ...;
                    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: ...;
                }>;
                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: ...;
            SetAssetClaimer: ...;
            SetErrorHandler: ...;
            SetFeesMode: ...;
            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;
            SetAssetClaimer: {
                location: ...;
            };
            SetErrorHandler: __Circular;
            SetFeesMode: {
                jit_withdraw: ...;
            };
            SetTopic: FixedSizeBinary<(...)>;
            SubscribeVersion: {
                max_response_weight: ...;
                query_id: ...;
            };
            Transact: {
                call: ...;
                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;
}>>>