Type Alias dry_run_call

dry_run_call: RuntimeDescriptor<
    [
        origin: Enum<
            {
                Origins: WestendRuntimeGovernanceOriginsPalletCustomOriginsOrigin;
                ParachainsOrigin: ParachainsOrigin;
                system: Enum<
                    {
                        Authorized: undefined;
                        None: undefined;
                        Root: undefined;
                        Signed: SS58String;
                    },
                >;
                XcmPallet: Enum<
                    {
                        Response: { interior: XcmV5Junctions; parents: number };
                        Xcm: { interior: XcmV5Junctions; parents: number };
                    },
                >;
            },
        >,
        call: TxCallData,
        result_xcms_version: number,
    ],
    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 };
                            BurnedDebt: { amount: bigint };
                            BurnedHeld: {
                                amount: bigint;
                                reason: Enum<
                                    {
                                        DelegatedStaking: ...;
                                        Preimage: ...;
                                        Session: ...;
                                        Staking: ...;
                                        XcmPallet: ...;
                                    },
                                >;
                                who: SS58String;
                            };
                            Deposit: { amount: bigint; who: SS58String };
                            DustLost: { account: SS58String; amount: bigint };
                            Endowed: { account: SS58String; free_balance: bigint };
                            Frozen: { amount: bigint; who: SS58String };
                            Held: {
                                amount: bigint;
                                reason: Enum<
                                    {
                                        DelegatedStaking: ...;
                                        Preimage: ...;
                                        Session: ...;
                                        Staking: ...;
                                        XcmPallet: ...;
                                    },
                                >;
                                who: SS58String;
                            };
                            Issued: { amount: bigint };
                            Locked: { amount: bigint; who: SS58String };
                            Minted: { amount: bigint; who: SS58String };
                            MintedCredit: { amount: bigint };
                            Released: {
                                amount: bigint;
                                reason: Enum<
                                    {
                                        DelegatedStaking: ...;
                                        Preimage: ...;
                                        Session: ...;
                                        Staking: ...;
                                        XcmPallet: ...;
                                    },
                                >;
                                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 };
                            TransferAndHold: {
                                dest: SS58String;
                                reason: Enum<
                                    {
                                        DelegatedStaking: ...;
                                        Preimage: ...;
                                        Session: ...;
                                        Staking: ...;
                                        XcmPallet: ...;
                                    },
                                >;
                                source: SS58String;
                                transferred: bigint;
                            };
                            TransferOnHold: {
                                amount: bigint;
                                dest: SS58String;
                                reason: Enum<
                                    {
                                        DelegatedStaking: ...;
                                        Preimage: ...;
                                        Session: ...;
                                        Staking: ...;
                                        XcmPallet: ...;
                                    },
                                >;
                                source: SS58String;
                            };
                            Unexpected: Enum<
                                { BalanceUpdated: undefined; FailedToMutateAccount: undefined },
                            >;
                            Unlocked: { amount: bigint; who: SS58String };
                            Unreserved: { amount: bigint; who: SS58String };
                            Upgraded: { who: SS58String };
                            Withdraw: { amount: bigint; who: SS58String };
                        },
                    >;
                    ConvictionVoting: Enum<
                        {
                            Delegated: [SS58String, SS58String, number];
                            Undelegated: [SS58String, number];
                            Voted: {
                                poll_index: number;
                                vote: ConvictionVotingVoteAccountVote;
                                who: SS58String;
                            };
                            VoteRemoved: {
                                poll_index: number;
                                vote: ConvictionVotingVoteAccountVote;
                                who: SS58String;
                            };
                            VoteUnlocked: { class: number; 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;
                    Historical: Enum<
                        { RootsPruned: { up_to: number }; RootStored: { index: number } },
                    >;
                    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: Enum<
                        {
                            DepositPoked: {
                                index: number;
                                new_deposit: bigint;
                                old_deposit: bigint;
                                who: SS58String;
                            };
                            IndexAssigned: { index: number; who: SS58String };
                            IndexFreed: { index: number };
                            IndexFrozen: { index: number; who: SS58String };
                        },
                    >;
                    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;
                            };
                        },
                    >;
                    MetaTx: Enum<
                        {
                            Dispatched: {
                                result: ResultPayload<
                                    { actual_weight?: ...; pays_fee: ... },
                                    { error: ...; post_info: ... },
                                >;
                            };
                        },
                    >;
                    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<
                        {
                            DepositPoked: {
                                call_hash: FixedSizeBinary<32>;
                                new_deposit: bigint;
                                old_deposit: bigint;
                                who: SS58String;
                            };
                            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 };
                            GlobalParamsUpdated: {
                                global_max_commission?: ...;
                                max_members?: ...;
                                max_members_per_pool?: ...;
                                max_pools?: ...;
                                min_create_bond: bigint;
                                min_join_bond: bigint;
                            };
                            MemberClaimPermissionUpdated: {
                                member: SS58String;
                                permission: NominationPoolsClaimPermission;
                            };
                            MemberRemoved: {
                                member: SS58String;
                                pool_id: number;
                                released_balance: bigint;
                            };
                            MetadataUpdated: { caller: SS58String; pool_id: number };
                            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 };
                            PoolNominationMade: { caller: SS58String; pool_id: number };
                            PoolNominatorChilled: { caller: SS58String; 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<
                        {
                            AccountCredited: { amount: bigint; who: SS58String };
                            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: Enum<
                        {
                            ActionQueued: FixedSizeArray<2, number>;
                            CodeAuthorized: {
                                code_hash: FixedSizeBinary<32>;
                                expire_at: number;
                                para_id: number;
                            };
                            CodeUpgradeScheduled: number;
                            CurrentCodeUpdated: number;
                            CurrentHeadUpdated: number;
                            NewHeadNoted: number;
                            PvfCheckAccepted: [FixedSizeBinary<32>, number];
                            PvfCheckRejected: [FixedSizeBinary<32>, number];
                            PvfCheckStarted: [FixedSizeBinary<32>, number];
                            UpgradeCooldownRemoved: { para_id: number };
                        },
                    >;
                    ParasDisputes: ParachainsDisputesEvent;
                    Preimage: PreimageEvent;
                    Proxy: Enum<
                        {
                            Announced: {
                                call_hash: FixedSizeBinary<32>;
                                proxy: SS58String;
                                real: SS58String;
                            };
                            DepositPoked: {
                                kind: Enum<{ Announcements: ...; Proxies: ... }>;
                                new_deposit: bigint;
                                old_deposit: bigint;
                                who: SS58String;
                            };
                            ProxyAdded: {
                                delay: number;
                                delegatee: SS58String;
                                delegator: SS58String;
                                proxy_type: Enum<
                                    {
                                        Any: ...;
                                        Auction: ...;
                                        CancelProxy: ...;
                                        Governance: ...;
                                        IdentityJudgement: ...;
                                        NominationPools: ...;
                                        NonTransfer: ...;
                                        ParaRegistration: ...;
                                        Staking: ...;
                                        SudoBalances: ...;
                                    },
                                >;
                            };
                            ProxyExecuted: { result: ResultPayload<undefined, Enum<(...)>> };
                            ProxyRemoved: {
                                delay: number;
                                delegatee: SS58String;
                                delegator: SS58String;
                                proxy_type: Enum<
                                    {
                                        Any: ...;
                                        Auction: ...;
                                        CancelProxy: ...;
                                        Governance: ...;
                                        IdentityJudgement: ...;
                                        NominationPools: ...;
                                        NonTransfer: ...;
                                        ParaRegistration: ...;
                                        Staking: ...;
                                        SudoBalances: ...;
                                    },
                                >;
                            };
                            PureCreated: {
                                at: number;
                                disambiguation_index: number;
                                extrinsic_index: number;
                                proxy_type: Enum<
                                    {
                                        Any: ...;
                                        Auction: ...;
                                        CancelProxy: ...;
                                        Governance: ...;
                                        IdentityJudgement: ...;
                                        NominationPools: ...;
                                        NonTransfer: ...;
                                        ParaRegistration: ...;
                                        Staking: ...;
                                        SudoBalances: ...;
                                    },
                                >;
                                pure: SS58String;
                                who: SS58String;
                            };
                            PureKilled: {
                                disambiguation_index: number;
                                proxy_type: Enum<
                                    {
                                        Any: ...;
                                        Auction: ...;
                                        CancelProxy: ...;
                                        Governance: ...;
                                        IdentityJudgement: ...;
                                        NominationPools: ...;
                                        NonTransfer: ...;
                                        ParaRegistration: ...;
                                        Staking: ...;
                                        SudoBalances: ...;
                                    },
                                >;
                                pure: SS58String;
                                spawner: SS58String;
                            };
                        },
                    >;
                    Recovery: Enum<
                        {
                            AccountRecovered: {
                                lost_account: SS58String;
                                rescuer_account: SS58String;
                            };
                            DepositPoked: {
                                kind: Enum<{ ActiveRecoveryFor: ...; RecoveryConfig: ... }>;
                                new_deposit: bigint;
                                old_deposit: bigint;
                                who: SS58String;
                            };
                            RecoveryClosed: {
                                lost_account: SS58String;
                                rescuer_account: SS58String;
                            };
                            RecoveryCreated: { account: SS58String };
                            RecoveryInitiated: {
                                lost_account: SS58String;
                                rescuer_account: SS58String;
                            };
                            RecoveryRemoved: { lost_account: SS58String };
                            RecoveryVouched: {
                                lost_account: SS58String;
                                rescuer_account: SS58String;
                                sender: 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;
                    RootOffences: Enum<{ OffenceCreated: { offenders: [(...), (...)][] } }>;
                    RootTesting: RootTestingEvent;
                    Scheduler: Enum<
                        {
                            AgendaIncomplete: { when: number };
                            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: Enum<
                        {
                            NewQueued: undefined;
                            NewSession: { session_index: number };
                            ValidatorDisabled: { validator: SS58String };
                            ValidatorReenabled: { validator: SS58String };
                        },
                    >;
                    Slots: CommonSlotsEvent;
                    Staking: Enum<
                        {
                            Bonded: { amount: bigint; stash: SS58String };
                            Chilled: { stash: SS58String };
                            ControllerBatchDeprecated: { failures: number };
                            CurrencyMigrated: { force_withdraw: bigint; stash: SS58String };
                            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 };
                        },
                    >;
                    StakingAhClient: Enum<
                        {
                            CouldNotMergeAndDropped: undefined;
                            SetTooSmallAndDropped: undefined;
                            Unexpected: Enum<
                                {
                                    OffenceSendFailed: undefined;
                                    ReceivedValidatorSetWhilePassive: undefined;
                                    SessionReportDropped: undefined;
                                    SessionReportSendFailed: undefined;
                                    UnexpectedModeTransition: undefined;
                                    ValidatorPointDropped: undefined;
                                },
                            >;
                            ValidatorSetReceived: {
                                id: number;
                                leftover: boolean;
                                new_validator_set_count: number;
                                prune_up_to?: ...;
                            };
                        },
                    >;
                    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 };
                            RejectedInvalidAuthorizedUpgrade: {
                                code_hash: FixedSizeBinary<32>;
                                error: Enum<
                                    {
                                        Arithmetic: ...;
                                        BadOrigin: ...;
                                        CannotLookup: ...;
                                        ConsumerRemaining: ...;
                                        Corruption: ...;
                                        Exhausted: ...;
                                        Module: ...;
                                        NoProviders: ...;
                                        Other: ...;
                                        RootNotAllowed: ...;
                                        Token: ...;
                                        TooManyConsumers: ...;
                                        Transactional: ...;
                                        Trie: ...;
                                        Unavailable: ...;
                                    },
                                >;
                            };
                            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: 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: ...;
                                        Trie: ...;
                                        Unavailable: ...;
                                    },
                                >;
                                index: number;
                            };
                            DispatchedAs: { result: ResultPayload<undefined, Enum<(...)>> };
                            IfElseFallbackCalled: {
                                main_error: Enum<
                                    {
                                        Arithmetic: ...;
                                        BadOrigin: ...;
                                        CannotLookup: ...;
                                        ConsumerRemaining: ...;
                                        Corruption: ...;
                                        Exhausted: ...;
                                        Module: ...;
                                        NoProviders: ...;
                                        Other: ...;
                                        RootNotAllowed: ...;
                                        Token: ...;
                                        TooManyConsumers: ...;
                                        Transactional: ...;
                                        Trie: ...;
                                        Unavailable: ...;
                                    },
                                >;
                            };
                            IfElseMainSuccess: undefined;
                            ItemCompleted: undefined;
                            ItemFailed: {
                                error: Enum<
                                    {
                                        Arithmetic: ...;
                                        BadOrigin: ...;
                                        CannotLookup: ...;
                                        ConsumerRemaining: ...;
                                        Corruption: ...;
                                        Exhausted: ...;
                                        Module: ...;
                                        NoProviders: ...;
                                        Other: ...;
                                        RootNotAllowed: ...;
                                        Token: ...;
                                        TooManyConsumers: ...;
                                        Transactional: ...;
                                        Trie: ...;
                                        Unavailable: ...;
                                    },
                                >;
                            };
                        },
                    >;
                    Vesting: Enum<
                        {
                            VestingCompleted: { account: SS58String };
                            VestingCreated: { account: SS58String; schedule_index: number };
                            VestingUpdated: { account: SS58String; unvested: bigint };
                        },
                    >;
                    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<
                        {
                            AliasAuthorizationRemoved: {
                                aliaser: { interior: XcmV5Junctions; parents: number };
                                target: { interior: XcmV5Junctions; parents: number };
                            };
                            AliasAuthorized: {
                                aliaser: { interior: XcmV5Junctions; parents: number };
                                expiry?: ...;
                                target: { interior: XcmV5Junctions; parents: number };
                            };
                            AliasesAuthorizationsRemoved: {
                                target: { interior: XcmV5Junctions; parents: number };
                            };
                            AssetsClaimed: {
                                assets: XcmVersionedAssets;
                                hash: FixedSizeBinary<32>;
                                origin: { interior: XcmV5Junctions; parents: number };
                            };
                            AssetsTrapped: {
                                assets: XcmVersionedAssets;
                                hash: FixedSizeBinary<32>;
                                origin: { interior: XcmV5Junctions; parents: number };
                            };
                            Attempted: {
                                outcome: Enum<{ Complete: ...; Error: ...; Incomplete: ... }>;
                            };
                            FeesPaid: {
                                fees: { fun: ...; id: ... }[];
                                paying: { interior: XcmV5Junctions; parents: number };
                            };
                            InvalidQuerier: {
                                expected_querier: { interior: XcmV5Junctions; parents: number };
                                maybe_actual_querier?: ...;
                                origin: { interior: XcmV5Junctions; parents: number };
                                query_id: bigint;
                            };
                            InvalidQuerierVersion: {
                                origin: { interior: XcmV5Junctions; parents: number };
                                query_id: bigint;
                            };
                            InvalidResponder: {
                                expected_location?: ...;
                                origin: { interior: XcmV5Junctions; parents: number };
                                query_id: bigint;
                            };
                            InvalidResponderVersion: {
                                origin: { interior: XcmV5Junctions; 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: 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: XcmV5Junctions; parents: number };
                                query_id: bigint;
                            };
                            ProcessXcmError: {
                                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: ...;
                                    },
                                >;
                                message_id: FixedSizeBinary<32>;
                                origin: { interior: XcmV5Junctions; parents: number };
                            };
                            ResponseReady: {
                                query_id: bigint;
                                response: Enum<
                                    {
                                        Assets: ...;
                                        DispatchResult: ...;
                                        ExecutionResult?: ...;
                                        Null: ...;
                                        PalletsInfo: ...;
                                        Version: ...;
                                    },
                                >;
                            };
                            ResponseTaken: { query_id: bigint };
                            SendFailed: {
                                destination: { interior: XcmV5Junctions; parents: number };
                                error: Enum<
                                    {
                                        DestinationUnsupported: ...;
                                        ExceedsMaxMessageSize: ...;
                                        Fees: ...;
                                        MissingArgument: ...;
                                        NotApplicable: ...;
                                        Transport: ...;
                                        Unroutable: ...;
                                    },
                                >;
                                message_id: FixedSizeBinary<32>;
                                origin: { interior: XcmV5Junctions; parents: number };
                            };
                            Sent: {
                                destination: { interior: XcmV5Junctions; parents: number };
                                message: XcmV5Instruction[];
                                message_id: FixedSizeBinary<32>;
                                origin: { interior: XcmV5Junctions; parents: number };
                            };
                            SupportedVersionChanged: {
                                location: { interior: XcmV5Junctions; parents: number };
                                version: number;
                            };
                            UnexpectedResponse: {
                                origin: { interior: XcmV5Junctions; parents: number };
                                query_id: bigint;
                            };
                            VersionChangeNotified: {
                                cost: { fun: ...; id: ... }[];
                                destination: { interior: XcmV5Junctions; parents: number };
                                message_id: FixedSizeBinary<32>;
                                result: number;
                            };
                            VersionMigrationFinished: { version: number };
                            VersionNotifyRequested: {
                                cost: { fun: ...; id: ... }[];
                                destination: { interior: XcmV5Junctions; parents: number };
                                message_id: FixedSizeBinary<32>;
                            };
                            VersionNotifyStarted: {
                                cost: { fun: ...; id: ... }[];
                                destination: { interior: XcmV5Junctions; parents: number };
                                message_id: FixedSizeBinary<32>;
                            };
                            VersionNotifyUnrequested: {
                                cost: { fun: ...; id: ... }[];
                                destination: { interior: XcmV5Junctions; 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: ...;
                                        },
                                    >;
                                    MetaTx: Enum<
                                        {
                                            AncientBirthBlock: ...;
                                            BadProof: ...;
                                            Future: ...;
                                            Invalid: ...;
                                            Stale: ...;
                                            UnknownOrigin: ...;
                                        },
                                    >;
                                    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: ...;
                                            Restricted: ...;
                                            RewardPoolNotFound: ...;
                                            SlashTooLow: ...;
                                            SubPoolsNotFound: ...;
                                        },
                                    >;
                                    Offences: undefined;
                                    OnDemandAssignmentProvider: Enum<
                                        {
                                            InsufficientCredits: ...;
                                            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: ...;
                                            InvalidBlockNumber: ...;
                                            InvalidCode: ...;
                                            NothingAuthorized: ...;
                                            NotRegistered: ...;
                                            PvfCheckDoubleVote: ...;
                                            PvfCheckInvalidSignature: ...;
                                            PvfCheckStatementFuture: ...;
                                            PvfCheckStatementStale: ...;
                                            PvfCheckSubjectInvalid: ...;
                                            PvfCheckValidatorIndexOutOfBounds: ...;
                                            Unauthorized: ...;
                                        },
                                    >;
                                    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: ...;
                                            Unroutable: ...;
                                        },
                                    >;
                                    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: ...;
                                        },
                                    >;
                                    RootOffences: Enum<{ FailedToGetActiveEra: ... }>;
                                    RootTesting: undefined;
                                    Scheduler: Enum<
                                        {
                                            FailedToSchedule: ...;
                                            Named: ...;
                                            NotFound: ...;
                                            RescheduleNoChange: ...;
                                            TargetBlockNumberInPast: ...;
                                        },
                                    >;
                                    Session: Enum<
                                        {
                                            DuplicatedKey: ...;
                                            InvalidProof: ...;
                                            NoAccount: ...;
                                            NoAssociatedValidatorId: ...;
                                            NoKeys: ...;
                                        },
                                    >;
                                    Slots: Enum<{ LeaseError: ...; ParaNotOnboarding: ... }>;
                                    Staking: Enum<
                                        {
                                            AlreadyBonded: ...;
                                            AlreadyClaimed: ...;
                                            AlreadyMigrated: ...;
                                            AlreadyPaired: ...;
                                            BadState: ...;
                                            BadTarget: ...;
                                            BoundNotMet: ...;
                                            CannotChillOther: ...;
                                            CannotReapStash: ...;
                                            CannotRestoreLedger: ...;
                                            CommissionTooLow: ...;
                                            ControllerDeprecated: ...;
                                            DuplicateIndex: ...;
                                            EmptyTargets: ...;
                                            FundedTarget: ...;
                                            IncorrectHistoryDepth: ...;
                                            IncorrectSlashingSpans: ...;
                                            InsufficientBond: ...;
                                            InvalidEraToReward: ...;
                                            InvalidNumberOfNominations: ...;
                                            InvalidPage: ...;
                                            InvalidSlashIndex: ...;
                                            NoMoreChunks: ...;
                                            NotController: ...;
                                            NotEnoughFunds: ...;
                                            NotSortedAndUnique: ...;
                                            NotStash: ...;
                                            NoUnlockChunk: ...;
                                            Restricted: ...;
                                            RewardDestinationRestricted: ...;
                                            TooManyNominators: ...;
                                            TooManyTargets: ...;
                                            TooManyValidators: ...;
                                            VirtualStakerNotAllowed: ...;
                                        },
                                    >;
                                    StakingAhClient: Enum<{ Blocked: ... }>;
                                    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: ... }>;
                                    VerifySignature: undefined;
                                    Vesting: Enum<
                                        {
                                            AmountLow: ...;
                                            AtMaxVestingSchedules: ...;
                                            InvalidScheduleParams: ...;
                                            NotVesting: ...;
                                            ScheduleIndexOutOfBounds: ...;
                                        },
                                    >;
                                    VoterList: Enum<{ List: ...; Locked: ... }>;
                                    Whitelist: Enum<
                                        {
                                            CallAlreadyWhitelisted: ...;
                                            CallIsNotWhitelisted: ...;
                                            InvalidCallWeightWitness: ...;
                                            UnavailablePreImage: ...;
                                            UndecodableCall: ...;
                                        },
                                    >;
                                    XcmPallet: Enum<
                                        {
                                            AccountNotSovereign: ...;
                                            AliasNotFound: ...;
                                            AlreadySubscribed: ...;
                                            BadLocation: ...;
                                            BadVersion: ...;
                                            CannotCheckOutTeleport: ...;
                                            CannotReanchor: ...;
                                            DestinationNotInvertible: ...;
                                            Empty: ...;
                                            ExpiresInPast: ...;
                                            FeesNotMet: ...;
                                            Filtered: ...;
                                            InUse: ...;
                                            InvalidAssetUnknownReserve: ...;
                                            InvalidAssetUnsupportedReserve: ...;
                                            InvalidOrigin: ...;
                                            LocalExecutionIncomplete: ...;
                                            LocalExecutionIncompleteWithError: ...;
                                            LockNotFound: ...;
                                            LowBalance: ...;
                                            NoSubscription: ...;
                                            SendFailure: ...;
                                            TooManyAssets: ...;
                                            TooManyAuthorizedAliases: ...;
                                            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: [XcmVersionedLocation, XcmVersionedXcm[]][];
            local_xcm?: XcmVersionedXcm;
        },
        Enum<{ Unimplemented: undefined; VersionedConversionFailed: undefined }>,
    >,
>