Type Alias dry_run_call

dry_run_call: RuntimeDescriptor<[origin: Enum<{
    Origins: WestendRuntimeGovernanceOriginsPalletCustomOriginsOrigin;
    ParachainsOrigin: ParachainsOrigin;
    system: DispatchRawOrigin;
    Void: undefined;
    XcmPallet: 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;
        };
    }>;
}>, call: TxCallData], ResultPayload<{
    emitted_events: Enum<{
        AssetRate: Enum<{
            AssetRateCreated: {
                asset_kind: Enum<{
                    V3: ...;
                    V4: ...;
                    V5: ...;
                }>;
                rate: bigint;
            };
            AssetRateRemoved: {
                asset_kind: Enum<{
                    V3: ...;
                    V4: ...;
                    V5: ...;
                }>;
            };
            AssetRateUpdated: {
                asset_kind: Enum<{
                    V3: ...;
                    V4: ...;
                    V5: ...;
                }>;
                new: bigint;
                old: bigint;
            };
        }>;
        AssignedSlots: PolkadotRuntimeCommonAssignedSlotsEvent;
        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;
            };
        }>;
        ConvictionVoting: Enum<{
            Delegated: FixedSizeArray<2, SS58String>;
            Undelegated: SS58String;
            Voted: {
                vote: ConvictionVotingVoteAccountVote;
                who: SS58String;
            };
            VoteRemoved: {
                vote: ConvictionVotingVoteAccountVote;
                who: SS58String;
            };
        }>;
        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;
            };
        }>;
        DelegatedStaking: Enum<{
            Delegated: {
                agent: SS58String;
                amount: bigint;
                delegator: SS58String;
            };
            MigratedDelegation: {
                agent: SS58String;
                amount: bigint;
                delegator: SS58String;
            };
            Released: {
                agent: SS58String;
                amount: bigint;
                delegator: SS58String;
            };
            Slashed: {
                agent: SS58String;
                amount: bigint;
                delegator: 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;
        Identity: Enum<{
            AuthorityAdded: {
                authority: SS58String;
            };
            AuthorityRemoved: {
                authority: SS58String;
            };
            DanglingUsernameRemoved: {
                username: Binary;
                who: SS58String;
            };
            IdentityCleared: {
                deposit: bigint;
                who: SS58String;
            };
            IdentityKilled: {
                deposit: bigint;
                who: SS58String;
            };
            IdentitySet: {
                who: SS58String;
            };
            JudgementGiven: {
                registrar_index: number;
                target: SS58String;
            };
            JudgementRequested: {
                registrar_index: number;
                who: SS58String;
            };
            JudgementUnrequested: {
                registrar_index: number;
                who: SS58String;
            };
            PreapprovalExpired: {
                whose: SS58String;
            };
            PrimaryUsernameSet: {
                username: Binary;
                who: SS58String;
            };
            RegistrarAdded: {
                registrar_index: number;
            };
            SubIdentitiesSet: {
                main: SS58String;
                new_deposit: bigint;
                number_of_subs: number;
            };
            SubIdentityAdded: {
                deposit: bigint;
                main: SS58String;
                sub: SS58String;
            };
            SubIdentityRemoved: {
                deposit: bigint;
                main: SS58String;
                sub: SS58String;
            };
            SubIdentityRenamed: {
                main: SS58String;
                sub: SS58String;
            };
            SubIdentityRevoked: {
                deposit: bigint;
                main: SS58String;
                sub: SS58String;
            };
            UsernameKilled: {
                username: Binary;
            };
            UsernameQueued: {
                expiration: number;
                username: Binary;
                who: SS58String;
            };
            UsernameRemoved: {
                username: Binary;
            };
            UsernameSet: {
                username: Binary;
                who: SS58String;
            };
            UsernameUnbound: {
                username: Binary;
            };
        }>;
        IdentityMigrator: PolkadotRuntimeCommonIdentityMigratorEvent;
        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;
            };
        }>;
        MultiBlockMigrations: Enum<{
            HistoricCleared: {
                next_cursor?: ...;
            };
            MigrationAdvanced: {
                index: number;
                took: number;
            };
            MigrationCompleted: {
                index: number;
                took: number;
            };
            MigrationFailed: {
                index: number;
                took: number;
            };
            MigrationSkipped: {
                index: number;
            };
            UpgradeCompleted: undefined;
            UpgradeFailed: undefined;
            UpgradeStarted: {
                migrations: number;
            };
        }>;
        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: Enum<{
            Bonded: {
                bonded: bigint;
                joined: boolean;
                member: SS58String;
                pool_id: number;
            };
            Created: {
                depositor: SS58String;
                pool_id: number;
            };
            Destroyed: {
                pool_id: number;
            };
            MemberRemoved: {
                member: SS58String;
                pool_id: number;
                released_balance: bigint;
            };
            MinBalanceDeficitAdjusted: {
                amount: bigint;
                pool_id: number;
            };
            MinBalanceExcessAdjusted: {
                amount: bigint;
                pool_id: number;
            };
            PaidOut: {
                member: SS58String;
                payout: bigint;
                pool_id: number;
            };
            PoolCommissionChangeRateUpdated: {
                change_rate: {
                    max_increase: number;
                    min_delay: number;
                };
                pool_id: number;
            };
            PoolCommissionClaimed: {
                commission: bigint;
                pool_id: number;
            };
            PoolCommissionClaimPermissionUpdated: {
                permission?: ...;
                pool_id: number;
            };
            PoolCommissionUpdated: {
                current?: ...;
                pool_id: number;
            };
            PoolMaxCommissionUpdated: {
                max_commission: number;
                pool_id: number;
            };
            PoolSlashed: {
                balance: bigint;
                pool_id: number;
            };
            RolesUpdated: {
                bouncer?: ...;
                nominator?: ...;
                root?: ...;
            };
            StateChanged: {
                new_state: NominationPoolsPoolState;
                pool_id: number;
            };
            Unbonded: {
                balance: bigint;
                era: number;
                member: SS58String;
                points: bigint;
                pool_id: number;
            };
            UnbondingPoolSlashed: {
                balance: bigint;
                era: number;
                pool_id: number;
            };
            Withdrawn: {
                balance: bigint;
                member: SS58String;
                points: bigint;
                pool_id: number;
            };
        }>;
        Offences: OffencesEvent;
        OnDemandAssignmentProvider: Enum<{
            OnDemandOrderPlaced: {
                ordered_by: SS58String;
                para_id: number;
                spot_price: bigint;
            };
            SpotPriceSet: {
                spot_price: bigint;
            };
        }>;
        ParaInclusion: Enum<{
            CandidateBacked: [{
                commitments_hash: FixedSizeBinary<(...)>;
                descriptor: {
                    core_index: ...;
                    erasure_root: ...;
                    para_head: ...;
                    para_id: ...;
                    persisted_validation_data_hash: ...;
                    pov_hash: ...;
                    relay_parent: ...;
                    reserved1: ...;
                    reserved2: ...;
                    session_index: ...;
                    validation_code_hash: ...;
                    version: ...;
                };
            }, Binary, number, number];
            CandidateIncluded: [{
                commitments_hash: FixedSizeBinary<(...)>;
                descriptor: {
                    core_index: ...;
                    erasure_root: ...;
                    para_head: ...;
                    para_id: ...;
                    persisted_validation_data_hash: ...;
                    pov_hash: ...;
                    relay_parent: ...;
                    reserved1: ...;
                    reserved2: ...;
                    session_index: ...;
                    validation_code_hash: ...;
                    version: ...;
                };
            }, Binary, number, number];
            CandidateTimedOut: [{
                commitments_hash: FixedSizeBinary<(...)>;
                descriptor: {
                    core_index: ...;
                    erasure_root: ...;
                    para_head: ...;
                    para_id: ...;
                    persisted_validation_data_hash: ...;
                    pov_hash: ...;
                    relay_parent: ...;
                    reserved1: ...;
                    reserved2: ...;
                    session_index: ...;
                    validation_code_hash: ...;
                    version: ...;
                };
            }, Binary, number];
            UpwardMessagesReceived: {
                count: number;
                from: number;
            };
        }>;
        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: WestendRuntimeProxyType;
            };
            ProxyExecuted: {
                result: ResultPayload<undefined, Enum<(...)>>;
            };
            ProxyRemoved: {
                delay: number;
                delegatee: SS58String;
                delegator: SS58String;
                proxy_type: WestendRuntimeProxyType;
            };
            PureCreated: {
                disambiguation_index: number;
                proxy_type: WestendRuntimeProxyType;
                pure: SS58String;
                who: SS58String;
            };
        }>;
        Recovery: RecoveryEvent;
        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;
        RootTesting: RootTestingEvent;
        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: Enum<{
            Bonded: {
                amount: bigint;
                stash: SS58String;
            };
            Chilled: {
                stash: SS58String;
            };
            ControllerBatchDeprecated: {
                failures: number;
            };
            EraPaid: {
                era_index: number;
                remainder: bigint;
                validator_payout: bigint;
            };
            ForceEra: {
                mode: StakingForcing;
            };
            Kicked: {
                nominator: SS58String;
                stash: SS58String;
            };
            OldSlashingReportDiscarded: {
                session_index: number;
            };
            PayoutStarted: {
                era_index: number;
                next?: ...;
                page: number;
                validator_stash: SS58String;
            };
            Rewarded: {
                amount: bigint;
                dest: StakingRewardDestination;
                stash: SS58String;
            };
            Slashed: {
                amount: bigint;
                staker: SS58String;
            };
            SlashReported: {
                fraction: number;
                slash_era: number;
                validator: SS58String;
            };
            SnapshotTargetsSizeExceeded: {
                size: number;
            };
            SnapshotVotersSizeExceeded: {
                size: number;
            };
            StakersElected: undefined;
            StakingElectionFailed: undefined;
            Unbonded: {
                amount: bigint;
                stash: SS58String;
            };
            ValidatorPrefsSet: {
                prefs: {
                    blocked: boolean;
                    commission: number;
                };
                stash: SS58String;
            };
            Withdrawn: {
                amount: bigint;
                stash: 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: ...;
                    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>;
            };
        }>;
        TransactionPayment: TransactionPaymentEvent;
        Treasury: Enum<{
            AssetSpendApproved: {
                amount: bigint;
                asset_kind: Enum<{
                    V3: ...;
                    V4: ...;
                    V5: ...;
                }>;
                beneficiary: Enum<{
                    V3: ...;
                    V4: ...;
                    V5: ...;
                }>;
                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: ...;
                    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: ...;
                }>;
            };
        }>;
        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: 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>;
            };
        }>;
    }>[];
    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<{
                AssetRate: Enum<{
                    AlreadyExists: ...;
                    Overflow: ...;
                    UnknownAssetKind: ...;
                }>;
                AssignedSlots: Enum<{
                    CannotDowngrade: ...;
                    CannotUpgrade: ...;
                    MaxPermanentSlotsExceeded: ...;
                    MaxTemporarySlotsExceeded: ...;
                    NotParathread: ...;
                    OngoingLeaseExists: ...;
                    ParaDoesntExist: ...;
                    SlotAlreadyAssigned: ...;
                    SlotNotAssigned: ...;
                }>;
                Auctions: Enum<{
                    AlreadyLeasedOut: ...;
                    AuctionEnded: ...;
                    AuctionInProgress: ...;
                    LeasePeriodInPast: ...;
                    NotAuction: ...;
                    NotCurrentAuction: ...;
                    ParaNotRegistered: ...;
                }>;
                AuthorityDiscovery: undefined;
                Authorship: undefined;
                Babe: Enum<{
                    DuplicateOffenceReport: ...;
                    InvalidConfiguration: ...;
                    InvalidEquivocationProof: ...;
                    InvalidKeyOwnershipProof: ...;
                }>;
                Balances: Enum<{
                    DeadAccount: ...;
                    DeltaZero: ...;
                    ExistentialDeposit: ...;
                    ExistingVestingSchedule: ...;
                    Expendability: ...;
                    InsufficientBalance: ...;
                    IssuanceDeactivated: ...;
                    LiquidityRestrictions: ...;
                    TooManyFreezes: ...;
                    TooManyHolds: ...;
                    TooManyReserves: ...;
                    VestingBalance: ...;
                }>;
                Beefy: Enum<{
                    DuplicateOffenceReport: ...;
                    InvalidConfiguration: ...;
                    InvalidDoubleVotingProof: ...;
                    InvalidEquivocationProofSession: ...;
                    InvalidForkVotingProof: ...;
                    InvalidFutureBlockVotingProof: ...;
                    InvalidKeyOwnershipProof: ...;
                }>;
                BeefyMmrLeaf: undefined;
                Configuration: Enum<{
                    InvalidNewValue: ...;
                }>;
                ConvictionVoting: Enum<{
                    AlreadyDelegating: ...;
                    AlreadyVoting: ...;
                    BadClass: ...;
                    ClassNeeded: ...;
                    InsufficientFunds: ...;
                    MaxVotesReached: ...;
                    Nonsense: ...;
                    NoPermission: ...;
                    NoPermissionYet: ...;
                    NotDelegating: ...;
                    NotOngoing: ...;
                    NotVoter: ...;
                }>;
                Coretime: Enum<{
                    AssetTransferFailed: ...;
                    NotBroker: ...;
                    RequestedFutureRevenue: ...;
                }>;
                CoretimeAssignmentProvider: Enum<{
                    AssignmentsEmpty: ...;
                    DisallowedInsert: ...;
                }>;
                Crowdloan: Enum<{
                    AlreadyInNewRaise: ...;
                    BidOrLeaseActive: ...;
                    CannotEndInPast: ...;
                    CapExceeded: ...;
                    ContributionPeriodOver: ...;
                    ContributionTooSmall: ...;
                    EndTooFarInFuture: ...;
                    FirstPeriodInPast: ...;
                    FirstPeriodTooFarInFuture: ...;
                    FundNotEnded: ...;
                    InvalidOrigin: ...;
                    InvalidParaId: ...;
                    InvalidSignature: ...;
                    LastPeriodBeforeFirstPeriod: ...;
                    LastPeriodTooFarInFuture: ...;
                    LeaseActive: ...;
                    MemoTooLarge: ...;
                    NoContributions: ...;
                    NoLeasePeriod: ...;
                    NotParachain: ...;
                    NotReadyToDissolve: ...;
                    Overflow: ...;
                    VrfDelayInProgress: ...;
                }>;
                DelegatedStaking: Enum<{
                    AlreadyStaking: ...;
                    BadState: ...;
                    InvalidDelegation: ...;
                    InvalidRewardDestination: ...;
                    NotAgent: ...;
                    NotAllowed: ...;
                    NotDelegator: ...;
                    NotEnoughFunds: ...;
                    NothingToSlash: ...;
                    NotSupported: ...;
                    UnappliedSlash: ...;
                    WithdrawFailed: ...;
                }>;
                Dmp: undefined;
                ElectionProviderMultiPhase: Enum<{
                    BoundNotMet: ...;
                    CallNotAllowed: ...;
                    FallbackFailed: ...;
                    InvalidSubmissionIndex: ...;
                    MissingSnapshotMetadata: ...;
                    OcwCallWrongEra: ...;
                    PreDispatchDifferentRound: ...;
                    PreDispatchEarlySubmission: ...;
                    PreDispatchWeakSubmission: ...;
                    PreDispatchWrongWinnerCount: ...;
                    SignedCannotPayDeposit: ...;
                    SignedInvalidWitness: ...;
                    SignedQueueFull: ...;
                    SignedTooMuchWeight: ...;
                    TooManyWinners: ...;
                }>;
                FastUnstake: Enum<{
                    AlreadyHead: ...;
                    AlreadyQueued: ...;
                    CallNotAllowed: ...;
                    NotController: ...;
                    NotFullyBonded: ...;
                    NotQueued: ...;
                }>;
                Grandpa: Enum<{
                    ChangePending: ...;
                    DuplicateOffenceReport: ...;
                    InvalidEquivocationProof: ...;
                    InvalidKeyOwnershipProof: ...;
                    PauseFailed: ...;
                    ResumeFailed: ...;
                    TooSoon: ...;
                }>;
                Historical: undefined;
                Hrmp: Enum<{
                    AcceptHrmpChannelAlreadyConfirmed: ...;
                    AcceptHrmpChannelDoesntExist: ...;
                    AcceptHrmpChannelLimitExceeded: ...;
                    CancelHrmpOpenChannelUnauthorized: ...;
                    ChannelCreationNotAuthorized: ...;
                    CloseHrmpChannelAlreadyUnderway: ...;
                    CloseHrmpChannelDoesntExist: ...;
                    CloseHrmpChannelUnauthorized: ...;
                    OpenHrmpChannelAlreadyConfirmed: ...;
                    OpenHrmpChannelAlreadyExists: ...;
                    OpenHrmpChannelAlreadyRequested: ...;
                    OpenHrmpChannelCapacityExceedsLimit: ...;
                    OpenHrmpChannelDoesntExist: ...;
                    OpenHrmpChannelInvalidRecipient: ...;
                    OpenHrmpChannelLimitExceeded: ...;
                    OpenHrmpChannelMessageSizeExceedsLimit: ...;
                    OpenHrmpChannelToSelf: ...;
                    OpenHrmpChannelZeroCapacity: ...;
                    OpenHrmpChannelZeroMessageSize: ...;
                    WrongWitness: ...;
                }>;
                Identity: Enum<{
                    AlreadyClaimed: ...;
                    AlreadyUnbinding: ...;
                    EmptyIndex: ...;
                    FeeChanged: ...;
                    InsufficientPrivileges: ...;
                    InvalidIndex: ...;
                    InvalidJudgement: ...;
                    InvalidSignature: ...;
                    InvalidSuffix: ...;
                    InvalidTarget: ...;
                    InvalidUsername: ...;
                    JudgementForDifferentIdentity: ...;
                    JudgementGiven: ...;
                    JudgementPaymentFailed: ...;
                    NoAllocation: ...;
                    NoIdentity: ...;
                    NotExpired: ...;
                    NotFound: ...;
                    NotNamed: ...;
                    NotOwned: ...;
                    NotSub: ...;
                    NotUnbinding: ...;
                    NotUsernameAuthority: ...;
                    NoUsername: ...;
                    RequiresSignature: ...;
                    StickyJudgement: ...;
                    TooEarly: ...;
                    TooManyRegistrars: ...;
                    TooManySubAccounts: ...;
                    UsernameTaken: ...;
                }>;
                IdentityMigrator: undefined;
                Indices: Enum<{
                    InUse: ...;
                    NotAssigned: ...;
                    NotOwner: ...;
                    NotTransfer: ...;
                    Permanent: ...;
                }>;
                Initializer: undefined;
                MessageQueue: Enum<{
                    AlreadyProcessed: ...;
                    InsufficientWeight: ...;
                    NoMessage: ...;
                    NoPage: ...;
                    NotReapable: ...;
                    Queued: ...;
                    QueuePaused: ...;
                    RecursiveDisallowed: ...;
                    TemporarilyUnprocessable: ...;
                }>;
                Mmr: undefined;
                MultiBlockMigrations: Enum<{
                    Ongoing: ...;
                }>;
                Multisig: Enum<{
                    AlreadyApproved: ...;
                    AlreadyStored: ...;
                    MaxWeightTooLow: ...;
                    MinimumThreshold: ...;
                    NoApprovalsNeeded: ...;
                    NotFound: ...;
                    NoTimepoint: ...;
                    NotOwner: ...;
                    SenderInSignatories: ...;
                    SignatoriesOutOfOrder: ...;
                    TooFewSignatories: ...;
                    TooManySignatories: ...;
                    UnexpectedTimepoint: ...;
                    WrongTimepoint: ...;
                }>;
                NominationPools: Enum<{
                    AccountBelongsToOtherPool: ...;
                    AlreadyMigrated: ...;
                    BondExtraRestricted: ...;
                    CanNotChangeState: ...;
                    CannotWithdrawAny: ...;
                    CommissionChangeRateNotAllowed: ...;
                    CommissionChangeThrottled: ...;
                    CommissionExceedsGlobalMaximum: ...;
                    CommissionExceedsMaximum: ...;
                    Defensive: ...;
                    DoesNotHavePermission: ...;
                    FullyUnbonding: ...;
                    InvalidPoolId: ...;
                    MaxCommissionRestricted: ...;
                    MaxPoolMembers: ...;
                    MaxPools: ...;
                    MaxUnbondingLimit: ...;
                    MetadataExceedsMaxLen: ...;
                    MinimumBondNotMet: ...;
                    NoCommissionCurrentSet: ...;
                    NoPendingCommission: ...;
                    NotDestroying: ...;
                    NothingToAdjust: ...;
                    NothingToSlash: ...;
                    NotKickerOrDestroying: ...;
                    NotMigrated: ...;
                    NotNominator: ...;
                    NotOpen: ...;
                    NotSupported: ...;
                    OverflowRisk: ...;
                    PartialUnbondNotAllowedPermissionlessly: ...;
                    PoolIdInUse: ...;
                    PoolMemberNotFound: ...;
                    PoolNotFound: ...;
                    RewardPoolNotFound: ...;
                    SubPoolsNotFound: ...;
                }>;
                Offences: undefined;
                OnDemandAssignmentProvider: Enum<{
                    QueueFull: ...;
                    SpotPriceHigherThanMaxAmount: ...;
                }>;
                Origins: undefined;
                ParachainsOrigin: undefined;
                ParaInclusion: Enum<{
                    DisallowedRelayParent: ...;
                    HeadDataTooLarge: ...;
                    HrmpWatermarkMishandling: ...;
                    IncorrectDownwardMessageHandling: ...;
                    InsufficientBacking: ...;
                    InvalidAssignment: ...;
                    InvalidBacking: ...;
                    InvalidGroupIndex: ...;
                    InvalidOutboundHrmp: ...;
                    InvalidUpwardMessages: ...;
                    InvalidValidationCodeHash: ...;
                    NewCodeTooLarge: ...;
                    ParaHeadMismatch: ...;
                    PrematureCodeUpgrade: ...;
                    UnscheduledCandidate: ...;
                    ValidationDataHashMismatch: ...;
                    ValidatorIndexOutOfBounds: ...;
                }>;
                ParaInherent: Enum<{
                    InherentDataFilteredDuringExecution: ...;
                    InvalidParentHeader: ...;
                    TooManyInclusionInherents: ...;
                    UnscheduledCandidate: ...;
                }>;
                Parameters: undefined;
                Paras: Enum<{
                    CannotDowngrade: ...;
                    CannotOffboard: ...;
                    CannotOnboard: ...;
                    CannotUpgrade: ...;
                    CannotUpgradeCode: ...;
                    InvalidCode: ...;
                    NotRegistered: ...;
                    PvfCheckDoubleVote: ...;
                    PvfCheckInvalidSignature: ...;
                    PvfCheckStatementFuture: ...;
                    PvfCheckStatementStale: ...;
                    PvfCheckSubjectInvalid: ...;
                    PvfCheckValidatorIndexOutOfBounds: ...;
                }>;
                ParaScheduler: undefined;
                ParasDisputes: Enum<{
                    AncientDisputeStatement: ...;
                    DuplicateDisputeStatementSets: ...;
                    DuplicateStatement: ...;
                    InvalidSignature: ...;
                    MaliciousBacker: ...;
                    MissingBackingVotes: ...;
                    SingleSidedDispute: ...;
                    UnconfirmedDispute: ...;
                    ValidatorIndexOutOfBounds: ...;
                }>;
                ParaSessionInfo: undefined;
                ParasShared: undefined;
                ParasSlashing: Enum<{
                    DuplicateSlashingReport: ...;
                    InvalidCandidateHash: ...;
                    InvalidKeyOwnershipProof: ...;
                    InvalidSessionIndex: ...;
                    InvalidValidatorIndex: ...;
                    ValidatorIndexIdMismatch: ...;
                }>;
                ParasSudoWrapper: Enum<{
                    CannotDowngrade: ...;
                    CannotUpgrade: ...;
                    CouldntCleanup: ...;
                    ExceedsMaxMessageSize: ...;
                    NotParachain: ...;
                    NotParathread: ...;
                    ParaAlreadyExists: ...;
                    ParaDoesntExist: ...;
                    TooManyCores: ...;
                }>;
                Preimage: Enum<{
                    AlreadyNoted: ...;
                    NotAuthorized: ...;
                    NotNoted: ...;
                    NotRequested: ...;
                    Requested: ...;
                    TooBig: ...;
                    TooFew: ...;
                    TooMany: ...;
                }>;
                Proxy: Enum<{
                    Duplicate: ...;
                    NoPermission: ...;
                    NoSelfProxy: ...;
                    NotFound: ...;
                    NotProxy: ...;
                    TooMany: ...;
                    Unannounced: ...;
                    Unproxyable: ...;
                }>;
                Recovery: Enum<{
                    AlreadyProxy: ...;
                    AlreadyRecoverable: ...;
                    AlreadyStarted: ...;
                    AlreadyVouched: ...;
                    BadState: ...;
                    DelayPeriod: ...;
                    MaxFriends: ...;
                    NotAllowed: ...;
                    NotEnoughFriends: ...;
                    NotFriend: ...;
                    NotRecoverable: ...;
                    NotSorted: ...;
                    NotStarted: ...;
                    StillActive: ...;
                    Threshold: ...;
                    ZeroThreshold: ...;
                }>;
                Referenda: Enum<{
                    BadReferendum: ...;
                    BadStatus: ...;
                    BadTrack: ...;
                    Full: ...;
                    HasDeposit: ...;
                    NoDeposit: ...;
                    NoPermission: ...;
                    NothingToDo: ...;
                    NotOngoing: ...;
                    NoTrack: ...;
                    PreimageNotExist: ...;
                    PreimageStoredWithDifferentLength: ...;
                    QueueEmpty: ...;
                    Unfinished: ...;
                }>;
                Registrar: Enum<{
                    AlreadyRegistered: ...;
                    CannotDeregister: ...;
                    CannotDowngrade: ...;
                    CannotSwap: ...;
                    CannotUpgrade: ...;
                    CodeTooLarge: ...;
                    HeadDataTooLarge: ...;
                    InvalidCode: ...;
                    NotOwner: ...;
                    NotParachain: ...;
                    NotParathread: ...;
                    NotRegistered: ...;
                    NotReserved: ...;
                    ParaLocked: ...;
                }>;
                RootTesting: undefined;
                Scheduler: Enum<{
                    FailedToSchedule: ...;
                    Named: ...;
                    NotFound: ...;
                    RescheduleNoChange: ...;
                    TargetBlockNumberInPast: ...;
                }>;
                Session: Enum<{
                    DuplicatedKey: ...;
                    InvalidProof: ...;
                    NoAccount: ...;
                    NoAssociatedValidatorId: ...;
                    NoKeys: ...;
                }>;
                Slots: Enum<{
                    LeaseError: ...;
                    ParaNotOnboarding: ...;
                }>;
                Staking: Enum<{
                    AlreadyBonded: ...;
                    AlreadyClaimed: ...;
                    AlreadyPaired: ...;
                    BadState: ...;
                    BadTarget: ...;
                    BoundNotMet: ...;
                    CannotChillOther: ...;
                    CannotRestoreLedger: ...;
                    CommissionTooLow: ...;
                    ControllerDeprecated: ...;
                    DuplicateIndex: ...;
                    EmptyTargets: ...;
                    FundedTarget: ...;
                    IncorrectHistoryDepth: ...;
                    IncorrectSlashingSpans: ...;
                    InsufficientBond: ...;
                    InvalidEraToReward: ...;
                    InvalidNumberOfNominations: ...;
                    InvalidPage: ...;
                    InvalidSlashIndex: ...;
                    NoMoreChunks: ...;
                    NotController: ...;
                    NotEnoughFunds: ...;
                    NotSortedAndUnique: ...;
                    NotStash: ...;
                    NoUnlockChunk: ...;
                    RewardDestinationRestricted: ...;
                    TooManyNominators: ...;
                    TooManyTargets: ...;
                    TooManyValidators: ...;
                    VirtualStakerNotAllowed: ...;
                }>;
                Sudo: Enum<{
                    RequireSudo: ...;
                }>;
                System: Enum<{
                    CallFiltered: ...;
                    FailedToExtractRuntimeVersion: ...;
                    InvalidSpecName: ...;
                    MultiBlockMigrationsOngoing: ...;
                    NonDefaultComposite: ...;
                    NonZeroRefCount: ...;
                    NothingAuthorized: ...;
                    SpecVersionNeedsToIncrease: ...;
                    Unauthorized: ...;
                }>;
                Timestamp: undefined;
                TransactionPayment: undefined;
                Treasury: Enum<{
                    AlreadyAttempted: ...;
                    EarlyPayout: ...;
                    FailedToConvertBalance: ...;
                    Inconclusive: ...;
                    InsufficientPermission: ...;
                    InvalidIndex: ...;
                    NotAttempted: ...;
                    PayoutError: ...;
                    ProposalNotApproved: ...;
                    SpendExpired: ...;
                    TooManyApprovals: ...;
                }>;
                Utility: Enum<{
                    TooManyCalls: ...;
                }>;
                Vesting: Enum<{
                    AmountLow: ...;
                    AtMaxVestingSchedules: ...;
                    InvalidScheduleParams: ...;
                    NotVesting: ...;
                    ScheduleIndexOutOfBounds: ...;
                }>;
                VoterList: Enum<{
                    List: ...;
                }>;
                Whitelist: Enum<{
                    CallAlreadyWhitelisted: ...;
                    CallIsNotWhitelisted: ...;
                    InvalidCallWeightWitness: ...;
                    UnavailablePreImage: ...;
                    UndecodableCall: ...;
                }>;
                XcmPallet: 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: ...;
                }>;
            }>;
            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;
}>>>