Type Alias dry_run_xcm

dry_run_xcm: RuntimeDescriptor<[origin_location: XcmVersionedLocation, xcm: XcmVersionedXcm], ResultPayload<{
    emitted_events: Enum<{
        AssetRate: AssetRateEvent;
        Auctions: CommonAuctionsEvent;
        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;
            };
        }>;
        Bounties: BountiesEvent;
        ChildBounties: ChildBountiesEvent;
        Claims: CommonClaimsEvent;
        ConvictionVoting: ConvictionVotingEvent;
        Coretime: PolkadotRuntimeParachainsCoretimeEvent;
        Crowdloan: Enum<{
            AddedToNewRaise: {
                para_id: number;
            };
            AllRefunded: {
                para_id: number;
            };
            Contributed: {
                amount: bigint;
                fund_index: number;
                who: SS58String;
            };
            Created: {
                para_id: number;
            };
            Dissolved: {
                para_id: number;
            };
            Edited: {
                para_id: number;
            };
            HandleBidResult: {
                para_id: number;
                result: ResultPayload<undefined, Enum<(...)>>;
            };
            MemoUpdated: {
                memo: Binary;
                para_id: number;
                who: SS58String;
            };
            PartiallyRefunded: {
                para_id: number;
            };
            Withdrew: {
                amount: bigint;
                fund_index: number;
                who: SS58String;
            };
        }>;
        ElectionProviderMultiPhase: ElectionProviderMultiPhaseEvent;
        FastUnstake: Enum<{
            BatchChecked: {
                eras: number[];
            };
            BatchFinished: {
                size: number;
            };
            InternalError: undefined;
            Slashed: {
                amount: bigint;
                stash: SS58String;
            };
            Unstaked: {
                result: ResultPayload<undefined, Enum<(...)>>;
                stash: SS58String;
            };
        }>;
        Grandpa: GrandpaEvent;
        Hrmp: ParachainsHrmpEvent;
        Indices: IndicesEvent;
        MessageQueue: Enum<{
            OverweightEnqueued: {
                id: FixedSizeBinary<32>;
                message_index: number;
                origin: ParachainsInclusionAggregateMessageOrigin;
                page_index: number;
            };
            PageReaped: {
                index: number;
                origin: ParachainsInclusionAggregateMessageOrigin;
            };
            Processed: {
                id: FixedSizeBinary<32>;
                origin: ParachainsInclusionAggregateMessageOrigin;
                success: boolean;
                weight_used: {
                    proof_size: bigint;
                    ref_time: bigint;
                };
            };
            ProcessingFailed: {
                error: Enum<{
                    BadFormat: ...;
                    Corrupt: ...;
                    Overweight: ...;
                    StackLimitReached: ...;
                    Unsupported: ...;
                    Yield: ...;
                }>;
                id: FixedSizeBinary<32>;
                origin: ParachainsInclusionAggregateMessageOrigin;
            };
        }>;
        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;
            };
        }>;
        NominationPools: NominationPoolsEvent;
        Offences: OffencesEvent;
        OnDemand: Enum<{
            OnDemandOrderPlaced: {
                ordered_by: SS58String;
                para_id: number;
                spot_price: bigint;
            };
            SpotPriceSet: {
                spot_price: bigint;
            };
        }>;
        ParaInclusion: ParachainsInclusionEvent;
        Parameters: Enum<{
            Updated: {
                key: Enum<{
                    Inflation: ...;
                }>;
                new_value?: ...;
                old_value?: ...;
            };
        }>;
        Paras: ParachainsParasEvent;
        ParasDisputes: ParachainsDisputesEvent;
        Preimage: PreimageEvent;
        Proxy: Enum<{
            Announced: {
                call_hash: FixedSizeBinary<32>;
                proxy: SS58String;
                real: SS58String;
            };
            ProxyAdded: {
                delay: number;
                delegatee: SS58String;
                delegator: SS58String;
                proxy_type: Enum<{
                    Any: ...;
                    Auction: ...;
                    CancelProxy: ...;
                    Governance: ...;
                    NominationPools: ...;
                    NonTransfer: ...;
                    Staking: ...;
                }>;
            };
            ProxyExecuted: {
                result: ResultPayload<undefined, Enum<(...)>>;
            };
            ProxyRemoved: {
                delay: number;
                delegatee: SS58String;
                delegator: SS58String;
                proxy_type: Enum<{
                    Any: ...;
                    Auction: ...;
                    CancelProxy: ...;
                    Governance: ...;
                    NominationPools: ...;
                    NonTransfer: ...;
                    Staking: ...;
                }>;
            };
            PureCreated: {
                disambiguation_index: number;
                proxy_type: Enum<{
                    Any: ...;
                    Auction: ...;
                    CancelProxy: ...;
                    Governance: ...;
                    NominationPools: ...;
                    NonTransfer: ...;
                    Staking: ...;
                }>;
                pure: SS58String;
                who: SS58String;
            };
        }>;
        Referenda: Enum<{
            Approved: {
                index: number;
            };
            Cancelled: {
                index: number;
                tally: {
                    ayes: bigint;
                    nays: bigint;
                    support: bigint;
                };
            };
            ConfirmAborted: {
                index: number;
            };
            Confirmed: {
                index: number;
                tally: {
                    ayes: bigint;
                    nays: bigint;
                    support: bigint;
                };
            };
            ConfirmStarted: {
                index: number;
            };
            DecisionDepositPlaced: {
                amount: bigint;
                index: number;
                who: SS58String;
            };
            DecisionDepositRefunded: {
                amount: bigint;
                index: number;
                who: SS58String;
            };
            DecisionStarted: {
                index: number;
                proposal: PreimagesBounded;
                tally: {
                    ayes: bigint;
                    nays: bigint;
                    support: bigint;
                };
                track: number;
            };
            DepositSlashed: {
                amount: bigint;
                who: SS58String;
            };
            Killed: {
                index: number;
                tally: {
                    ayes: bigint;
                    nays: bigint;
                    support: bigint;
                };
            };
            MetadataCleared: {
                hash: FixedSizeBinary<32>;
                index: number;
            };
            MetadataSet: {
                hash: FixedSizeBinary<32>;
                index: number;
            };
            Rejected: {
                index: number;
                tally: {
                    ayes: bigint;
                    nays: bigint;
                    support: bigint;
                };
            };
            SubmissionDepositRefunded: {
                amount: bigint;
                index: number;
                who: SS58String;
            };
            Submitted: {
                index: number;
                proposal: PreimagesBounded;
                track: number;
            };
            TimedOut: {
                index: number;
                tally: {
                    ayes: bigint;
                    nays: bigint;
                    support: bigint;
                };
            };
        }>;
        Registrar: CommonParasRegistrarEvent;
        Scheduler: Enum<{
            CallUnavailable: {
                id?: ...;
                task: FixedSizeArray<2, number>;
            };
            Canceled: {
                index: number;
                when: number;
            };
            Dispatched: {
                id?: ...;
                result: ResultPayload<undefined, Enum<(...)>>;
                task: FixedSizeArray<2, number>;
            };
            PeriodicFailed: {
                id?: ...;
                task: FixedSizeArray<2, number>;
            };
            PermanentlyOverweight: {
                id?: ...;
                task: FixedSizeArray<2, number>;
            };
            RetryCancelled: {
                id?: ...;
                task: FixedSizeArray<2, number>;
            };
            RetryFailed: {
                id?: ...;
                task: FixedSizeArray<2, number>;
            };
            RetrySet: {
                id?: ...;
                period: number;
                retries: number;
                task: FixedSizeArray<2, number>;
            };
            Scheduled: {
                index: number;
                when: number;
            };
        }>;
        Session: SessionEvent;
        Slots: CommonSlotsEvent;
        Staking: StakingEvent;
        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;
            };
        }>;
        Sudo: Enum<{
            KeyChanged: {
                new: SS58String;
                old?: ...;
            };
            KeyRemoved: undefined;
            Sudid: {
                sudo_result: ResultPayload<undefined, Enum<(...)>>;
            };
            SudoAsDone: {
                sudo_result: ResultPayload<undefined, Enum<(...)>>;
            };
        }>;
        System: Enum<{
            CodeUpdated: undefined;
            ExtrinsicFailed: {
                dispatch_error: Enum<{
                    Arithmetic: ...;
                    BadOrigin: ...;
                    CannotLookup: ...;
                    ConsumerRemaining: ...;
                    Corruption: ...;
                    Exhausted: ...;
                    Module: ...;
                    NoProviders: ...;
                    Other: ...;
                    RootNotAllowed: ...;
                    Token: ...;
                    TooManyConsumers: ...;
                    Transactional: ...;
                    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>;
            };
        }>;
        TransactionPayment: TransactionPaymentEvent;
        Treasury: Enum<{
            AssetSpendApproved: {
                amount: bigint;
                asset_kind: VersionedLocatableAsset;
                beneficiary: XcmVersionedLocation;
                expire_at: number;
                index: number;
                valid_from: number;
            };
            AssetSpendVoided: {
                index: number;
            };
            Awarded: {
                account: SS58String;
                award: bigint;
                proposal_index: number;
            };
            Burnt: {
                burnt_funds: bigint;
            };
            Deposit: {
                value: bigint;
            };
            Paid: {
                index: number;
                payment_id: bigint;
            };
            PaymentFailed: {
                index: number;
                payment_id: bigint;
            };
            Rollover: {
                rollover_balance: bigint;
            };
            SpendApproved: {
                amount: bigint;
                beneficiary: SS58String;
                proposal_index: number;
            };
            Spending: {
                budget_remaining: bigint;
            };
            SpendProcessed: {
                index: number;
            };
            UpdatedInactive: {
                deactivated: bigint;
                reactivated: bigint;
            };
        }>;
        Utility: Enum<{
            BatchCompleted: undefined;
            BatchCompletedWithErrors: undefined;
            BatchInterrupted: {
                error: Enum<{
                    Arithmetic: ...;
                    BadOrigin: ...;
                    CannotLookup: ...;
                    ConsumerRemaining: ...;
                    Corruption: ...;
                    Exhausted: ...;
                    Module: ...;
                    NoProviders: ...;
                    Other: ...;
                    RootNotAllowed: ...;
                    Token: ...;
                    TooManyConsumers: ...;
                    Transactional: ...;
                    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: ...;
                    Unavailable: ...;
                }>;
            };
        }>;
        Vesting: VestingEvent;
        VoterList: BagsListEvent;
        Whitelist: Enum<{
            CallWhitelisted: {
                call_hash: FixedSizeBinary<32>;
            };
            WhitelistedCallDispatched: {
                call_hash: FixedSizeBinary<32>;
                result: ResultPayload<{
                    actual_weight?: ...;
                    pays_fee: ...;
                }, {
                    error: ...;
                    post_info: ...;
                }>;
            };
            WhitelistedCallRemoved: {
                call_hash: FixedSizeBinary<32>;
            };
        }>;
        XcmPallet: Enum<{
            AssetsClaimed: {
                assets: XcmVersionedAssets;
                hash: FixedSizeBinary<32>;
                origin: {
                    interior: XcmV3Junctions;
                    parents: number;
                };
            };
            AssetsTrapped: {
                assets: XcmVersionedAssets;
                hash: FixedSizeBinary<32>;
                origin: {
                    interior: XcmV3Junctions;
                    parents: number;
                };
            };
            Attempted: {
                outcome: XcmV4TraitsOutcome;
            };
            FeesPaid: {
                fees: {
                    fun: ...;
                    id: ...;
                }[];
                paying: {
                    interior: XcmV3Junctions;
                    parents: number;
                };
            };
            InvalidQuerier: {
                expected_querier: {
                    interior: XcmV3Junctions;
                    parents: number;
                };
                maybe_actual_querier?: ...;
                origin: {
                    interior: XcmV3Junctions;
                    parents: number;
                };
                query_id: bigint;
            };
            InvalidQuerierVersion: {
                origin: {
                    interior: XcmV3Junctions;
                    parents: number;
                };
                query_id: bigint;
            };
            InvalidResponder: {
                expected_location?: ...;
                origin: {
                    interior: XcmV3Junctions;
                    parents: number;
                };
                query_id: bigint;
            };
            InvalidResponderVersion: {
                origin: {
                    interior: XcmV3Junctions;
                    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: XcmVersionedLocation;
                query_id: bigint;
            };
            NotifyTargetSendFail: {
                error: XcmV3TraitsError;
                location: {
                    interior: XcmV3Junctions;
                    parents: number;
                };
                query_id: bigint;
            };
            ResponseReady: {
                query_id: bigint;
                response: XcmV4Response;
            };
            ResponseTaken: {
                query_id: bigint;
            };
            Sent: {
                destination: {
                    interior: XcmV3Junctions;
                    parents: number;
                };
                message: XcmV4Instruction[];
                message_id: FixedSizeBinary<32>;
                origin: {
                    interior: XcmV3Junctions;
                    parents: number;
                };
            };
            SupportedVersionChanged: {
                location: {
                    interior: XcmV3Junctions;
                    parents: number;
                };
                version: number;
            };
            UnexpectedResponse: {
                origin: {
                    interior: XcmV3Junctions;
                    parents: number;
                };
                query_id: bigint;
            };
            VersionChangeNotified: {
                cost: {
                    fun: ...;
                    id: ...;
                }[];
                destination: {
                    interior: XcmV3Junctions;
                    parents: number;
                };
                message_id: FixedSizeBinary<32>;
                result: number;
            };
            VersionMigrationFinished: {
                version: number;
            };
            VersionNotifyRequested: {
                cost: {
                    fun: ...;
                    id: ...;
                }[];
                destination: {
                    interior: XcmV3Junctions;
                    parents: number;
                };
                message_id: FixedSizeBinary<32>;
            };
            VersionNotifyStarted: {
                cost: {
                    fun: ...;
                    id: ...;
                }[];
                destination: {
                    interior: XcmV3Junctions;
                    parents: number;
                };
                message_id: FixedSizeBinary<32>;
            };
            VersionNotifyUnrequested: {
                cost: {
                    fun: ...;
                    id: ...;
                }[];
                destination: {
                    interior: XcmV3Junctions;
                    parents: number;
                };
                message_id: FixedSizeBinary<32>;
            };
        }>;
    }>[];
    execution_result: XcmV4TraitsOutcome;
    forwarded_xcms: [XcmVersionedLocation, XcmVersionedXcm[]][];
}, Enum<{
    Unimplemented: undefined;
    VersionedConversionFailed: undefined;
}>>>