import type { Bytes, Compact, Data, Option, U256, U8aFixed, Vec, bool, u16, u32, u64, u8 } from '@polkadot/types';
import type { AnyNumber, ITuple } from '@polkadot/types/types';
import type { CID, ClassIdOf, Properties, TokenIdOf } from './nft';
import type { CurrencyIdOf, ScalarData, TreeId, WithdrawProof } from './webb';
import type { AssetDestroyWitness, TAssetBalance } from '@polkadot/types/interfaces/assets';
import type { MemberCount, ProposalIndex } from '@polkadot/types/interfaces/collective';
import type { CodeHash } from '@polkadot/types/interfaces/contracts';
import type { AccountVote, Conviction, PropIndex, Proposal, ReferendumIndex } from '@polkadot/types/interfaces/democracy';
import type { Renouncing } from '@polkadot/types/interfaces/elections';
import type { EthTransaction } from '@polkadot/types/interfaces/eth';
import type { Extrinsic, Signature } from '@polkadot/types/interfaces/extrinsics';
import type { GrandpaEquivocationProof, KeyOwnerProof } from '@polkadot/types/interfaces/grandpa';
import type { IdentityFields, IdentityInfo, IdentityJudgement, RegistrarIndex } from '@polkadot/types/interfaces/identity';
import type { Heartbeat } from '@polkadot/types/interfaces/imOnline';
import type { ProxyType } from '@polkadot/types/interfaces/proxy';
import type { AccountId, AccountIndex, AssetId, Balance, BalanceOf, BlockNumber, Call, CallHashOf, ChangesTrieConfiguration, H160, H256, Hash, Header, KeyValue, LookupSource, Moment, OpaqueCall, Perbill, Percent, Weight } from '@polkadot/types/interfaces/runtime';
import type { Period, Priority } from '@polkadot/types/interfaces/scheduler';
import type { Keys } from '@polkadot/types/interfaces/session';
import type { EraIndex, RawSolution, RewardDestination, SolutionOrSnapshotSize, ValidatorPrefs } from '@polkadot/types/interfaces/staking';
import type { Key } from '@polkadot/types/interfaces/system';
import type { BountyIndex } from '@polkadot/types/interfaces/treasury';
import type { Timepoint } from '@polkadot/types/interfaces/utility';
import type { VestingInfo } from '@polkadot/types/interfaces/vesting';
import type { ApiTypes, SubmittableExtrinsic } from '@polkadot/api/types';
declare module '@polkadot/api/types/submittable' {
    interface AugmentedSubmittables<ApiType> {
        assets: {
            /**
             * Approve an amount of asset for transfer by a delegated third-party account.
             *
             * Origin must be Signed.
             *
             * Ensures that `ApprovalDeposit` worth of `Currency` is reserved from signing account
             * for the purpose of holding the approval. If some non-zero amount of assets is already
             * approved from signing account to `delegate`, then it is topped up or unreserved to
             * meet the right value.
             *
             * NOTE: The signing account does not need to own `amount` of assets at the point of
             * making this call.
             *
             * - `id`: The identifier of the asset.
             * - `delegate`: The account to delegate permission to transfer asset.
             * - `amount`: The amount of asset that may be transferred by `delegate`. If there is
             * already an approval in place, then this acts additively.
             *
             * Emits `ApprovedTransfer` on success.
             *
             * Weight: `O(1)`
             **/
            approveTransfer: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, delegate: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, amount: Compact<TAssetBalance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, Compact<TAssetBalance>]>;
            /**
             * Reduce the balance of `who` by as much as possible up to `amount` assets of `id`.
             *
             * Origin must be Signed and the sender should be the Manager of the asset `id`.
             *
             * Bails with `BalanceZero` if the `who` is already dead.
             *
             * - `id`: The identifier of the asset to have some amount burned.
             * - `who`: The account to be debited from.
             * - `amount`: The maximum amount by which `who`'s balance should be reduced.
             *
             * Emits `Burned` with the actual amount burned. If this takes the balance to below the
             * minimum for the asset, then the amount burned is increased to take it to zero.
             *
             * Weight: `O(1)`
             * Modes: Post-existence of `who`; Pre & post Zombie-status of `who`.
             **/
            burn: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, who: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, amount: Compact<TAssetBalance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, Compact<TAssetBalance>]>;
            /**
             * Cancel all of some asset approved for delegated transfer by a third-party account.
             *
             * Origin must be Signed and there must be an approval in place between signer and
             * `delegate`.
             *
             * Unreserves any deposit previously reserved by `approve_transfer` for the approval.
             *
             * - `id`: The identifier of the asset.
             * - `delegate`: The account delegated permission to transfer asset.
             *
             * Emits `ApprovalCancelled` on success.
             *
             * Weight: `O(1)`
             **/
            cancelApproval: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, delegate: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource]>;
            /**
             * Clear the metadata for an asset.
             *
             * Origin must be Signed and the sender should be the Owner of the asset `id`.
             *
             * Any deposit is freed for the asset owner.
             *
             * - `id`: The identifier of the asset to clear.
             *
             * Emits `MetadataCleared`.
             *
             * Weight: `O(1)`
             **/
            clearMetadata: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>]>;
            /**
             * Issue a new class of fungible assets from a public origin.
             *
             * This new asset class has no assets initially and its owner is the origin.
             *
             * The origin must be Signed and the sender must have sufficient funds free.
             *
             * Funds of sender are reserved by `AssetDeposit`.
             *
             * Parameters:
             * - `id`: The identifier of the new asset. This must not be currently in use to identify
             * an existing asset.
             * - `admin`: The admin of this class of assets. The admin is the initial address of each
             * member of the asset class's admin team.
             * - `min_balance`: The minimum balance of this new asset that any single account must
             * have. If an account's balance is reduced below this, then it collapses to zero.
             *
             * Emits `Created` event when successful.
             *
             * Weight: `O(1)`
             **/
            create: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, admin: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, minBalance: TAssetBalance | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, TAssetBalance]>;
            /**
             * Destroy a class of fungible assets.
             *
             * The origin must conform to `ForceOrigin` or must be Signed and the sender must be the
             * owner of the asset `id`.
             *
             * - `id`: The identifier of the asset to be destroyed. This must identify an existing
             * asset.
             *
             * Emits `Destroyed` event when successful.
             *
             * Weight: `O(c + p + a)` where:
             * - `c = (witness.accounts - witness.sufficients)`
             * - `s = witness.sufficients`
             * - `a = witness.approvals`
             **/
            destroy: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, witness: AssetDestroyWitness | {
                accounts?: any;
                sufficients?: any;
                approvals?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, AssetDestroyWitness]>;
            /**
             * Alter the attributes of a given asset.
             *
             * Origin must be `ForceOrigin`.
             *
             * - `id`: The identifier of the asset.
             * - `owner`: The new Owner of this asset.
             * - `issuer`: The new Issuer of this asset.
             * - `admin`: The new Admin of this asset.
             * - `freezer`: The new Freezer of this asset.
             * - `min_balance`: The minimum balance of this new asset that any single account must
             * have. If an account's balance is reduced below this, then it collapses to zero.
             * - `is_sufficient`: Whether a non-zero balance of this asset is deposit of sufficient
             * value to account for the state bloat associated with its balance storage. If set to
             * `true`, then non-zero balances may be stored without a `consumer` reference (and thus
             * an ED in the Balances pallet or whatever else is used to control user-account state
             * growth).
             * - `is_frozen`: Whether this asset class is frozen except for permissioned/admin
             * instructions.
             *
             * Emits `AssetStatusChanged` with the identity of the asset.
             *
             * Weight: `O(1)`
             **/
            forceAssetStatus: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, owner: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, issuer: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, admin: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, freezer: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, minBalance: Compact<TAssetBalance> | AnyNumber | Uint8Array, isSufficient: bool | boolean | Uint8Array, isFrozen: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, LookupSource, LookupSource, LookupSource, Compact<TAssetBalance>, bool, bool]>;
            /**
             * Cancel all of some asset approved for delegated transfer by a third-party account.
             *
             * Origin must be either ForceOrigin or Signed origin with the signer being the Admin
             * account of the asset `id`.
             *
             * Unreserves any deposit previously reserved by `approve_transfer` for the approval.
             *
             * - `id`: The identifier of the asset.
             * - `delegate`: The account delegated permission to transfer asset.
             *
             * Emits `ApprovalCancelled` on success.
             *
             * Weight: `O(1)`
             **/
            forceCancelApproval: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, owner: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, delegate: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, LookupSource]>;
            /**
             * Clear the metadata for an asset.
             *
             * Origin must be ForceOrigin.
             *
             * Any deposit is returned.
             *
             * - `id`: The identifier of the asset to clear.
             *
             * Emits `MetadataCleared`.
             *
             * Weight: `O(1)`
             **/
            forceClearMetadata: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>]>;
            /**
             * Issue a new class of fungible assets from a privileged origin.
             *
             * This new asset class has no assets initially.
             *
             * The origin must conform to `ForceOrigin`.
             *
             * Unlike `create`, no funds are reserved.
             *
             * - `id`: The identifier of the new asset. This must not be currently in use to identify
             * an existing asset.
             * - `owner`: The owner of this class of assets. The owner has full superuser permissions
             * over this asset, but may later change and configure the permissions using `transfer_ownership`
             * and `set_team`.
             * - `max_zombies`: The total number of accounts which may hold assets in this class yet
             * have no existential deposit.
             * - `min_balance`: The minimum balance of this new asset that any single account must
             * have. If an account's balance is reduced below this, then it collapses to zero.
             *
             * Emits `ForceCreated` event when successful.
             *
             * Weight: `O(1)`
             **/
            forceCreate: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, owner: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, isSufficient: bool | boolean | Uint8Array, minBalance: Compact<TAssetBalance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, bool, Compact<TAssetBalance>]>;
            /**
             * Force the metadata for an asset to some value.
             *
             * Origin must be ForceOrigin.
             *
             * Any deposit is left alone.
             *
             * - `id`: The identifier of the asset to update.
             * - `name`: The user friendly name of this asset. Limited in length by `StringLimit`.
             * - `symbol`: The exchange symbol for this asset. Limited in length by `StringLimit`.
             * - `decimals`: The number of decimals this asset uses to represent one unit.
             *
             * Emits `MetadataSet`.
             *
             * Weight: `O(N + S)` where N and S are the length of the name and symbol respectively.
             **/
            forceSetMetadata: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, name: Bytes | string | Uint8Array, symbol: Bytes | string | Uint8Array, decimals: u8 | AnyNumber | Uint8Array, isFrozen: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, Bytes, Bytes, u8, bool]>;
            /**
             * Move some assets from one account to another.
             *
             * Origin must be Signed and the sender should be the Admin of the asset `id`.
             *
             * - `id`: The identifier of the asset to have some amount transferred.
             * - `source`: The account to be debited.
             * - `dest`: The account to be credited.
             * - `amount`: The amount by which the `source`'s balance of assets should be reduced and
             * `dest`'s balance increased. The amount actually transferred may be slightly greater in
             * the case that the transfer would otherwise take the `source` balance above zero but
             * below the minimum balance. Must be greater than zero.
             *
             * Emits `Transferred` with the actual amount transferred. If this takes the source balance
             * to below the minimum for the asset, then the amount transferred is increased to take it
             * to zero.
             *
             * Weight: `O(1)`
             * Modes: Pre-existence of `dest`; Post-existence of `source`; Prior & post zombie-status
             * of `source`; Account pre-existence of `dest`.
             **/
            forceTransfer: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, source: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, dest: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, amount: Compact<TAssetBalance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, LookupSource, Compact<TAssetBalance>]>;
            /**
             * Disallow further unprivileged transfers from an account.
             *
             * Origin must be Signed and the sender should be the Freezer of the asset `id`.
             *
             * - `id`: The identifier of the asset to be frozen.
             * - `who`: The account to be frozen.
             *
             * Emits `Frozen`.
             *
             * Weight: `O(1)`
             **/
            freeze: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, who: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource]>;
            /**
             * Disallow further unprivileged transfers for the asset class.
             *
             * Origin must be Signed and the sender should be the Freezer of the asset `id`.
             *
             * - `id`: The identifier of the asset to be frozen.
             *
             * Emits `Frozen`.
             *
             * Weight: `O(1)`
             **/
            freezeAsset: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>]>;
            /**
             * Mint assets of a particular class.
             *
             * The origin must be Signed and the sender must be the Issuer of the asset `id`.
             *
             * - `id`: The identifier of the asset to have some amount minted.
             * - `beneficiary`: The account to be credited with the minted assets.
             * - `amount`: The amount of the asset to be minted.
             *
             * Emits `Destroyed` event when successful.
             *
             * Weight: `O(1)`
             * Modes: Pre-existing balance of `beneficiary`; Account pre-existence of `beneficiary`.
             **/
            mint: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, beneficiary: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, amount: Compact<TAssetBalance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, Compact<TAssetBalance>]>;
            /**
             * Set the metadata for an asset.
             *
             * Origin must be Signed and the sender should be the Owner of the asset `id`.
             *
             * Funds of sender are reserved according to the formula:
             * `MetadataDepositBase + MetadataDepositPerByte * (name.len + symbol.len)` taking into
             * account any already reserved funds.
             *
             * - `id`: The identifier of the asset to update.
             * - `name`: The user friendly name of this asset. Limited in length by `StringLimit`.
             * - `symbol`: The exchange symbol for this asset. Limited in length by `StringLimit`.
             * - `decimals`: The number of decimals this asset uses to represent one unit.
             *
             * Emits `MetadataSet`.
             *
             * Weight: `O(1)`
             **/
            setMetadata: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, name: Bytes | string | Uint8Array, symbol: Bytes | string | Uint8Array, decimals: u8 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, Bytes, Bytes, u8]>;
            /**
             * Change the Issuer, Admin and Freezer of an asset.
             *
             * Origin must be Signed and the sender should be the Owner of the asset `id`.
             *
             * - `id`: The identifier of the asset to be frozen.
             * - `issuer`: The new Issuer of this asset.
             * - `admin`: The new Admin of this asset.
             * - `freezer`: The new Freezer of this asset.
             *
             * Emits `TeamChanged`.
             *
             * Weight: `O(1)`
             **/
            setTeam: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, issuer: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, admin: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, freezer: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, LookupSource, LookupSource]>;
            /**
             * Allow unprivileged transfers from an account again.
             *
             * Origin must be Signed and the sender should be the Admin of the asset `id`.
             *
             * - `id`: The identifier of the asset to be frozen.
             * - `who`: The account to be unfrozen.
             *
             * Emits `Thawed`.
             *
             * Weight: `O(1)`
             **/
            thaw: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, who: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource]>;
            /**
             * Allow unprivileged transfers for the asset again.
             *
             * Origin must be Signed and the sender should be the Admin of the asset `id`.
             *
             * - `id`: The identifier of the asset to be frozen.
             *
             * Emits `Thawed`.
             *
             * Weight: `O(1)`
             **/
            thawAsset: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>]>;
            /**
             * Move some assets from the sender account to another.
             *
             * Origin must be Signed.
             *
             * - `id`: The identifier of the asset to have some amount transferred.
             * - `target`: The account to be credited.
             * - `amount`: The amount by which the sender's balance of assets should be reduced and
             * `target`'s balance increased. The amount actually transferred may be slightly greater in
             * the case that the transfer would otherwise take the sender balance above zero but below
             * the minimum balance. Must be greater than zero.
             *
             * Emits `Transferred` with the actual amount transferred. If this takes the source balance
             * to below the minimum for the asset, then the amount transferred is increased to take it
             * to zero.
             *
             * Weight: `O(1)`
             * Modes: Pre-existence of `target`; Post-existence of sender; Prior & post zombie-status
             * of sender; Account pre-existence of `target`.
             **/
            transfer: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, target: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, amount: Compact<TAssetBalance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, Compact<TAssetBalance>]>;
            /**
             * Transfer some asset balance from a previously delegated account to some third-party
             * account.
             *
             * Origin must be Signed and there must be an approval in place by the `owner` to the
             * signer.
             *
             * If the entire amount approved for transfer is transferred, then any deposit previously
             * reserved by `approve_transfer` is unreserved.
             *
             * - `id`: The identifier of the asset.
             * - `owner`: The account which previously approved for a transfer of at least `amount` and
             * from which the asset balance will be withdrawn.
             * - `destination`: The account to which the asset balance of `amount` will be transferred.
             * - `amount`: The amount of assets to transfer.
             *
             * Emits `TransferredApproved` on success.
             *
             * Weight: `O(1)`
             **/
            transferApproved: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, owner: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, destination: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, amount: Compact<TAssetBalance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, LookupSource, Compact<TAssetBalance>]>;
            /**
             * Move some assets from the sender account to another, keeping the sender account alive.
             *
             * Origin must be Signed.
             *
             * - `id`: The identifier of the asset to have some amount transferred.
             * - `target`: The account to be credited.
             * - `amount`: The amount by which the sender's balance of assets should be reduced and
             * `target`'s balance increased. The amount actually transferred may be slightly greater in
             * the case that the transfer would otherwise take the sender balance above zero but below
             * the minimum balance. Must be greater than zero.
             *
             * Emits `Transferred` with the actual amount transferred. If this takes the source balance
             * to below the minimum for the asset, then the amount transferred is increased to take it
             * to zero.
             *
             * Weight: `O(1)`
             * Modes: Pre-existence of `target`; Post-existence of sender; Prior & post zombie-status
             * of sender; Account pre-existence of `target`.
             **/
            transferKeepAlive: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, target: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, amount: Compact<TAssetBalance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, Compact<TAssetBalance>]>;
            /**
             * Change the Owner of an asset.
             *
             * Origin must be Signed and the sender should be the Owner of the asset `id`.
             *
             * - `id`: The identifier of the asset.
             * - `owner`: The new Owner of this asset.
             *
             * Emits `OwnerChanged`.
             *
             * Weight: `O(1)`
             **/
            transferOwnership: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, owner: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        authorship: {
            /**
             * Provide a set of uncles.
             **/
            setUncles: AugmentedSubmittable<(newUncles: Vec<Header> | (Header | {
                parentHash?: any;
                number?: any;
                stateRoot?: any;
                extrinsicsRoot?: any;
                digest?: any;
            } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Header>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        balances: {
            /**
             * Exactly as `transfer`, except the origin must be root and the source account may be
             * specified.
             * # <weight>
             * - Same as transfer, but additional read and write because the source account is
             * not assumed to be in the overlay.
             * # </weight>
             **/
            forceTransfer: AugmentedSubmittable<(source: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, dest: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, value: Compact<Balance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, LookupSource, Compact<Balance>]>;
            /**
             * Set the balances of a given account.
             *
             * This will alter `FreeBalance` and `ReservedBalance` in storage. it will
             * also decrease the total issuance of the system (`TotalIssuance`).
             * If the new free or reserved balance is below the existential deposit,
             * it will reset the account nonce (`frame_system::AccountNonce`).
             *
             * The dispatch origin for this call is `root`.
             *
             * # <weight>
             * - Independent of the arguments.
             * - Contains a limited number of reads and writes.
             * ---------------------
             * - Base Weight:
             * - Creating: 27.56 µs
             * - Killing: 35.11 µs
             * - DB Weight: 1 Read, 1 Write to `who`
             * # </weight>
             **/
            setBalance: AugmentedSubmittable<(who: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, newFree: Compact<Balance> | AnyNumber | Uint8Array, newReserved: Compact<Balance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Compact<Balance>, Compact<Balance>]>;
            /**
             * Transfer some liquid free balance to another account.
             *
             * `transfer` will set the `FreeBalance` of the sender and receiver.
             * It will decrease the total issuance of the system by the `TransferFee`.
             * If the sender's account is below the existential deposit as a result
             * of the transfer, the account will be reaped.
             *
             * The dispatch origin for this call must be `Signed` by the transactor.
             *
             * # <weight>
             * - Dependent on arguments but not critical, given proper implementations for
             * input config types. See related functions below.
             * - It contains a limited number of reads and writes internally and no complex computation.
             *
             * Related functions:
             *
             * - `ensure_can_withdraw` is always called internally but has a bounded complexity.
             * - Transferring balances to accounts that did not exist before will cause
             * `T::OnNewAccount::on_new_account` to be called.
             * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.
             * - `transfer_keep_alive` works the same way as `transfer`, but has an additional
             * check that the transfer will not kill the origin account.
             * ---------------------------------
             * - Base Weight: 73.64 µs, worst case scenario (account created, account removed)
             * - DB Weight: 1 Read and 1 Write to destination account
             * - Origin account is already in memory, so no DB operations for them.
             * # </weight>
             **/
            transfer: AugmentedSubmittable<(dest: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, value: Compact<Balance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Compact<Balance>]>;
            /**
             * Same as the [`transfer`] call, but with a check that the transfer will not kill the
             * origin account.
             *
             * 99% of the time you want [`transfer`] instead.
             *
             * [`transfer`]: struct.Pallet.html#method.transfer
             * # <weight>
             * - Cheaper than transfer because account cannot be killed.
             * - Base Weight: 51.4 µs
             * - DB Weight: 1 Read and 1 Write to dest (sender is in overlay already)
             * #</weight>
             **/
            transferKeepAlive: AugmentedSubmittable<(dest: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, value: Compact<Balance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Compact<Balance>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        bounties: {
            /**
             * Accept the curator role for a bounty.
             * A deposit will be reserved from curator and refund upon successful payout.
             *
             * May only be called from the curator.
             *
             * # <weight>
             * - O(1).
             * # </weight>
             **/
            acceptCurator: AugmentedSubmittable<(bountyId: Compact<BountyIndex> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BountyIndex>]>;
            /**
             * Approve a bounty proposal. At a later time, the bounty will be funded and become active
             * and the original deposit will be returned.
             *
             * May only be called from `T::ApproveOrigin`.
             *
             * # <weight>
             * - O(1).
             * # </weight>
             **/
            approveBounty: AugmentedSubmittable<(bountyId: Compact<BountyIndex> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BountyIndex>]>;
            /**
             * Award bounty to a beneficiary account. The beneficiary will be able to claim the funds after a delay.
             *
             * The dispatch origin for this call must be the curator of this bounty.
             *
             * - `bounty_id`: Bounty ID to award.
             * - `beneficiary`: The beneficiary account whom will receive the payout.
             *
             * # <weight>
             * - O(1).
             * # </weight>
             **/
            awardBounty: AugmentedSubmittable<(bountyId: Compact<BountyIndex> | AnyNumber | Uint8Array, beneficiary: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BountyIndex>, LookupSource]>;
            /**
             * Claim the payout from an awarded bounty after payout delay.
             *
             * The dispatch origin for this call must be the beneficiary of this bounty.
             *
             * - `bounty_id`: Bounty ID to claim.
             *
             * # <weight>
             * - O(1).
             * # </weight>
             **/
            claimBounty: AugmentedSubmittable<(bountyId: Compact<BountyIndex> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BountyIndex>]>;
            /**
             * Cancel a proposed or active bounty. All the funds will be sent to treasury and
             * the curator deposit will be unreserved if possible.
             *
             * Only `T::RejectOrigin` is able to cancel a bounty.
             *
             * - `bounty_id`: Bounty ID to cancel.
             *
             * # <weight>
             * - O(1).
             * # </weight>
             **/
            closeBounty: AugmentedSubmittable<(bountyId: Compact<BountyIndex> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BountyIndex>]>;
            /**
             * Extend the expiry time of an active bounty.
             *
             * The dispatch origin for this call must be the curator of this bounty.
             *
             * - `bounty_id`: Bounty ID to extend.
             * - `remark`: additional information.
             *
             * # <weight>
             * - O(1).
             * # </weight>
             **/
            extendBountyExpiry: AugmentedSubmittable<(bountyId: Compact<BountyIndex> | AnyNumber | Uint8Array, remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BountyIndex>, Bytes]>;
            /**
             * Propose a new bounty.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * Payment: `TipReportDepositBase` will be reserved from the origin account, as well as
             * `DataDepositPerByte` for each byte in `reason`. It will be unreserved upon approval,
             * or slashed when rejected.
             *
             * - `curator`: The curator account whom will manage this bounty.
             * - `fee`: The curator fee.
             * - `value`: The total payment amount of this bounty, curator fee included.
             * - `description`: The description of this bounty.
             **/
            proposeBounty: AugmentedSubmittable<(value: Compact<BalanceOf> | AnyNumber | Uint8Array, description: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BalanceOf>, Bytes]>;
            /**
             * Assign a curator to a funded bounty.
             *
             * May only be called from `T::ApproveOrigin`.
             *
             * # <weight>
             * - O(1).
             * # </weight>
             **/
            proposeCurator: AugmentedSubmittable<(bountyId: Compact<BountyIndex> | AnyNumber | Uint8Array, curator: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, fee: Compact<BalanceOf> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BountyIndex>, LookupSource, Compact<BalanceOf>]>;
            /**
             * Unassign curator from a bounty.
             *
             * This function can only be called by the `RejectOrigin` a signed origin.
             *
             * If this function is called by the `RejectOrigin`, we assume that the curator is malicious
             * or inactive. As a result, we will slash the curator when possible.
             *
             * If the origin is the curator, we take this as a sign they are unable to do their job and
             * they willingly give up. We could slash them, but for now we allow them to recover their
             * deposit and exit without issue. (We may want to change this if it is abused.)
             *
             * Finally, the origin can be anyone if and only if the curator is "inactive". This allows
             * anyone in the community to call out that a curator is not doing their due diligence, and
             * we should pick a new curator. In this case the curator should also be slashed.
             *
             * # <weight>
             * - O(1).
             * # </weight>
             **/
            unassignCurator: AugmentedSubmittable<(bountyId: Compact<BountyIndex> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BountyIndex>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        contracts: {
            /**
             * Makes a call to an account, optionally transferring some balance.
             *
             * * If the account is a smart-contract account, the associated code will be
             * executed and any value will be transferred.
             * * If the account is a regular account, any value will be transferred.
             * * If no account exists and the call value is not less than `existential_deposit`,
             * a regular account will be created and any value will be transferred.
             **/
            call: AugmentedSubmittable<(dest: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, value: Compact<BalanceOf> | AnyNumber | Uint8Array, gasLimit: Compact<Weight> | AnyNumber | Uint8Array, data: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Compact<BalanceOf>, Compact<Weight>, Bytes]>;
            /**
             * Allows block producers to claim a small reward for evicting a contract. If a block
             * producer fails to do so, a regular users will be allowed to claim the reward.
             *
             * In case of a successful eviction no fees are charged from the sender. However, the
             * reward is capped by the total amount of rent that was payed by the contract while
             * it was alive.
             *
             * If contract is not evicted as a result of this call, [`Error::ContractNotEvictable`]
             * is returned and the sender is not eligible for the reward.
             **/
            claimSurcharge: AugmentedSubmittable<(dest: AccountId | string | Uint8Array, auxSender: Option<AccountId> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, Option<AccountId>]>;
            /**
             * Instantiates a contract from a previously deployed wasm binary.
             *
             * This function is identical to [`Self::instantiate_with_code`] but without the
             * code deployment step. Instead, the `code_hash` of an on-chain deployed wasm binary
             * must be supplied.
             **/
            instantiate: AugmentedSubmittable<(endowment: Compact<BalanceOf> | AnyNumber | Uint8Array, gasLimit: Compact<Weight> | AnyNumber | Uint8Array, codeHash: CodeHash | string | Uint8Array, data: Bytes | string | Uint8Array, salt: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BalanceOf>, Compact<Weight>, CodeHash, Bytes, Bytes]>;
            /**
             * Instantiates a new contract from the supplied `code` optionally transferring
             * some balance.
             *
             * This is the only function that can deploy new code to the chain.
             *
             * # Parameters
             *
             * * `endowment`: The balance to transfer from the `origin` to the newly created contract.
             * * `gas_limit`: The gas limit enforced when executing the constructor.
             * * `code`: The contract code to deploy in raw bytes.
             * * `data`: The input data to pass to the contract constructor.
             * * `salt`: Used for the address derivation. See [`Pallet::contract_address`].
             *
             * Instantiation is executed as follows:
             *
             * - The supplied `code` is instrumented, deployed, and a `code_hash` is created for that code.
             * - If the `code_hash` already exists on the chain the underlying `code` will be shared.
             * - The destination address is computed based on the sender, code_hash and the salt.
             * - The smart-contract account is created at the computed address.
             * - The `endowment` is transferred to the new account.
             * - The `deploy` function is executed in the context of the newly-created account.
             **/
            instantiateWithCode: AugmentedSubmittable<(endowment: Compact<BalanceOf> | AnyNumber | Uint8Array, gasLimit: Compact<Weight> | AnyNumber | Uint8Array, code: Bytes | string | Uint8Array, data: Bytes | string | Uint8Array, salt: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BalanceOf>, Compact<Weight>, Bytes, Bytes, Bytes]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        council: {
            /**
             * Close a vote that is either approved, disapproved or whose voting period has ended.
             *
             * May be called by any signed account in order to finish voting and close the proposal.
             *
             * If called before the end of the voting period it will only close the vote if it is
             * has enough votes to be approved or disapproved.
             *
             * If called after the end of the voting period abstentions are counted as rejections
             * unless there is a prime member set and the prime member cast an approval.
             *
             * If the close operation completes successfully with disapproval, the transaction fee will
             * be waived. Otherwise execution of the approved operation will be charged to the caller.
             *
             * + `proposal_weight_bound`: The maximum amount of weight consumed by executing the closed proposal.
             * + `length_bound`: The upper bound for the length of the proposal in storage. Checked via
             * `storage::read` so it is `size_of::<u32>() == 4` larger than the pure length.
             *
             * # <weight>
             * ## Weight
             * - `O(B + M + P1 + P2)` where:
             * - `B` is `proposal` size in bytes (length-fee-bounded)
             * - `M` is members-count (code- and governance-bounded)
             * - `P1` is the complexity of `proposal` preimage.
             * - `P2` is proposal-count (code-bounded)
             * - DB:
             * - 2 storage reads (`Members`: codec `O(M)`, `Prime`: codec `O(1)`)
             * - 3 mutations (`Voting`: codec `O(M)`, `ProposalOf`: codec `O(B)`, `Proposals`: codec `O(P2)`)
             * - any mutations done while executing `proposal` (`P1`)
             * - up to 3 events
             * # </weight>
             **/
            close: AugmentedSubmittable<(proposalHash: Hash | string | Uint8Array, index: Compact<ProposalIndex> | AnyNumber | Uint8Array, proposalWeightBound: Compact<Weight> | AnyNumber | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash, Compact<ProposalIndex>, Compact<Weight>, Compact<u32>]>;
            /**
             * Disapprove a proposal, close, and remove it from the system, regardless of its current state.
             *
             * Must be called by the Root origin.
             *
             * Parameters:
             * * `proposal_hash`: The hash of the proposal that should be disapproved.
             *
             * # <weight>
             * Complexity: O(P) where P is the number of max proposals
             * DB Weight:
             * * Reads: Proposals
             * * Writes: Voting, Proposals, ProposalOf
             * # </weight>
             **/
            disapproveProposal: AugmentedSubmittable<(proposalHash: Hash | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash]>;
            /**
             * Dispatch a proposal from a member using the `Member` origin.
             *
             * Origin must be a member of the collective.
             *
             * # <weight>
             * ## Weight
             * - `O(M + P)` where `M` members-count (code-bounded) and `P` complexity of dispatching `proposal`
             * - DB: 1 read (codec `O(M)`) + DB access of `proposal`
             * - 1 event
             * # </weight>
             **/
            execute: AugmentedSubmittable<(proposal: Proposal | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Proposal, Compact<u32>]>;
            /**
             * Add a new proposal to either be voted on or executed directly.
             *
             * Requires the sender to be member.
             *
             * `threshold` determines whether `proposal` is executed directly (`threshold < 2`)
             * or put up for voting.
             *
             * # <weight>
             * ## Weight
             * - `O(B + M + P1)` or `O(B + M + P2)` where:
             * - `B` is `proposal` size in bytes (length-fee-bounded)
             * - `M` is members-count (code- and governance-bounded)
             * - branching is influenced by `threshold` where:
             * - `P1` is proposal execution complexity (`threshold < 2`)
             * - `P2` is proposals-count (code-bounded) (`threshold >= 2`)
             * - DB:
             * - 1 storage read `is_member` (codec `O(M)`)
             * - 1 storage read `ProposalOf::contains_key` (codec `O(1)`)
             * - DB accesses influenced by `threshold`:
             * - EITHER storage accesses done by `proposal` (`threshold < 2`)
             * - OR proposal insertion (`threshold <= 2`)
             * - 1 storage mutation `Proposals` (codec `O(P2)`)
             * - 1 storage mutation `ProposalCount` (codec `O(1)`)
             * - 1 storage write `ProposalOf` (codec `O(B)`)
             * - 1 storage write `Voting` (codec `O(M)`)
             * - 1 event
             * # </weight>
             **/
            propose: AugmentedSubmittable<(threshold: Compact<MemberCount> | AnyNumber | Uint8Array, proposal: Proposal | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<MemberCount>, Proposal, Compact<u32>]>;
            /**
             * Set the collective's membership.
             *
             * - `new_members`: The new member list. Be nice to the chain and provide it sorted.
             * - `prime`: The prime member whose vote sets the default.
             * - `old_count`: The upper bound for the previous number of members in storage.
             * Used for weight estimation.
             *
             * Requires root origin.
             *
             * NOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but
             * the weight estimations rely on it to estimate dispatchable weight.
             *
             * # <weight>
             * ## Weight
             * - `O(MP + N)` where:
             * - `M` old-members-count (code- and governance-bounded)
             * - `N` new-members-count (code- and governance-bounded)
             * - `P` proposals-count (code-bounded)
             * - DB:
             * - 1 storage mutation (codec `O(M)` read, `O(N)` write) for reading and writing the members
             * - 1 storage read (codec `O(P)`) for reading the proposals
             * - `P` storage mutations (codec `O(M)`) for updating the votes for each proposal
             * - 1 storage write (codec `O(1)`) for deleting the old `prime` and setting the new one
             * # </weight>
             **/
            setMembers: AugmentedSubmittable<(newMembers: Vec<AccountId> | (AccountId | string | Uint8Array)[], prime: Option<AccountId> | null | object | string | Uint8Array, oldCount: MemberCount | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<AccountId>, Option<AccountId>, MemberCount]>;
            /**
             * Add an aye or nay vote for the sender to the given proposal.
             *
             * Requires the sender to be a member.
             *
             * Transaction fees will be waived if the member is voting on any particular proposal
             * for the first time and the call is successful. Subsequent vote changes will charge a fee.
             * # <weight>
             * ## Weight
             * - `O(M)` where `M` is members-count (code- and governance-bounded)
             * - DB:
             * - 1 storage read `Members` (codec `O(M)`)
             * - 1 storage mutation `Voting` (codec `O(M)`)
             * - 1 event
             * # </weight>
             **/
            vote: AugmentedSubmittable<(proposal: Hash | string | Uint8Array, index: Compact<ProposalIndex> | AnyNumber | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash, Compact<ProposalIndex>, bool]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        democracy: {
            /**
             * Permanently place a proposal into the blacklist. This prevents it from ever being
             * proposed again.
             *
             * If called on a queued public or external proposal, then this will result in it being
             * removed. If the `ref_index` supplied is an active referendum with the proposal hash,
             * then it will be cancelled.
             *
             * The dispatch origin of this call must be `BlacklistOrigin`.
             *
             * - `proposal_hash`: The proposal hash to blacklist permanently.
             * - `ref_index`: An ongoing referendum whose hash is `proposal_hash`, which will be
             * cancelled.
             *
             * Weight: `O(p)` (though as this is an high-privilege dispatch, we assume it has a
             * reasonable value).
             **/
            blacklist: AugmentedSubmittable<(proposalHash: Hash | string | Uint8Array, maybeRefIndex: Option<ReferendumIndex> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash, Option<ReferendumIndex>]>;
            /**
             * Remove a proposal.
             *
             * The dispatch origin of this call must be `CancelProposalOrigin`.
             *
             * - `prop_index`: The index of the proposal to cancel.
             *
             * Weight: `O(p)` where `p = PublicProps::<T>::decode_len()`
             **/
            cancelProposal: AugmentedSubmittable<(propIndex: Compact<PropIndex> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<PropIndex>]>;
            /**
             * Cancel a proposal queued for enactment.
             *
             * The dispatch origin of this call must be _Root_.
             *
             * - `which`: The index of the referendum to cancel.
             *
             * Weight: `O(D)` where `D` is the items in the dispatch queue. Weighted as `D = 10`.
             **/
            cancelQueued: AugmentedSubmittable<(which: ReferendumIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [ReferendumIndex]>;
            /**
             * Remove a referendum.
             *
             * The dispatch origin of this call must be _Root_.
             *
             * - `ref_index`: The index of the referendum to cancel.
             *
             * # Weight: `O(1)`.
             **/
            cancelReferendum: AugmentedSubmittable<(refIndex: Compact<ReferendumIndex> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<ReferendumIndex>]>;
            /**
             * Clears all public proposals.
             *
             * The dispatch origin of this call must be _Root_.
             *
             * Weight: `O(1)`.
             **/
            clearPublicProposals: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Delegate the voting power (with some given conviction) of the sending account.
             *
             * The balance delegated is locked for as long as it's delegated, and thereafter for the
             * time appropriate for the conviction's lock period.
             *
             * The dispatch origin of this call must be _Signed_, and the signing account must either:
             * - be delegating already; or
             * - have no voting activity (if there is, then it will need to be removed/consolidated
             * through `reap_vote` or `unvote`).
             *
             * - `to`: The account whose voting the `target` account's voting power will follow.
             * - `conviction`: The conviction that will be attached to the delegated votes. When the
             * account is undelegated, the funds will be locked for the corresponding period.
             * - `balance`: The amount of the account's balance to be used in delegating. This must
             * not be more than the account's current balance.
             *
             * Emits `Delegated`.
             *
             * Weight: `O(R)` where R is the number of referendums the voter delegating to has
             * voted on. Weight is charged as if maximum votes.
             **/
            delegate: AugmentedSubmittable<(to: AccountId | string | Uint8Array, conviction: Conviction | 'None' | 'Locked1x' | 'Locked2x' | 'Locked3x' | 'Locked4x' | 'Locked5x' | 'Locked6x' | number | Uint8Array, balance: BalanceOf | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, Conviction, BalanceOf]>;
            /**
             * Schedule an emergency cancellation of a referendum. Cannot happen twice to the same
             * referendum.
             *
             * The dispatch origin of this call must be `CancellationOrigin`.
             *
             * -`ref_index`: The index of the referendum to cancel.
             *
             * Weight: `O(1)`.
             **/
            emergencyCancel: AugmentedSubmittable<(refIndex: ReferendumIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [ReferendumIndex]>;
            /**
             * Enact a proposal from a referendum. For now we just make the weight be the maximum.
             **/
            enactProposal: AugmentedSubmittable<(proposalHash: Hash | string | Uint8Array, index: ReferendumIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash, ReferendumIndex]>;
            /**
             * Schedule a referendum to be tabled once it is legal to schedule an external
             * referendum.
             *
             * The dispatch origin of this call must be `ExternalOrigin`.
             *
             * - `proposal_hash`: The preimage hash of the proposal.
             *
             * Weight: `O(V)` with V number of vetoers in the blacklist of proposal.
             * Decoding vec of length V. Charged as maximum
             **/
            externalPropose: AugmentedSubmittable<(proposalHash: Hash | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash]>;
            /**
             * Schedule a negative-turnout-bias referendum to be tabled next once it is legal to
             * schedule an external referendum.
             *
             * The dispatch of this call must be `ExternalDefaultOrigin`.
             *
             * - `proposal_hash`: The preimage hash of the proposal.
             *
             * Unlike `external_propose`, blacklisting has no effect on this and it may replace a
             * pre-scheduled `external_propose` call.
             *
             * Weight: `O(1)`
             **/
            externalProposeDefault: AugmentedSubmittable<(proposalHash: Hash | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash]>;
            /**
             * Schedule a majority-carries referendum to be tabled next once it is legal to schedule
             * an external referendum.
             *
             * The dispatch of this call must be `ExternalMajorityOrigin`.
             *
             * - `proposal_hash`: The preimage hash of the proposal.
             *
             * Unlike `external_propose`, blacklisting has no effect on this and it may replace a
             * pre-scheduled `external_propose` call.
             *
             * Weight: `O(1)`
             **/
            externalProposeMajority: AugmentedSubmittable<(proposalHash: Hash | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash]>;
            /**
             * Schedule the currently externally-proposed majority-carries referendum to be tabled
             * immediately. If there is no externally-proposed referendum currently, or if there is one
             * but it is not a majority-carries referendum then it fails.
             *
             * The dispatch of this call must be `FastTrackOrigin`.
             *
             * - `proposal_hash`: The hash of the current external proposal.
             * - `voting_period`: The period that is allowed for voting on this proposal. Increased to
             * `FastTrackVotingPeriod` if too low.
             * - `delay`: The number of block after voting has ended in approval and this should be
             * enacted. This doesn't have a minimum amount.
             *
             * Emits `Started`.
             *
             * Weight: `O(1)`
             **/
            fastTrack: AugmentedSubmittable<(proposalHash: Hash | string | Uint8Array, votingPeriod: BlockNumber | AnyNumber | Uint8Array, delay: BlockNumber | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash, BlockNumber, BlockNumber]>;
            /**
             * Register the preimage for an upcoming proposal. This requires the proposal to be
             * in the dispatch queue. No deposit is needed. When this call is successful, i.e.
             * the preimage has not been uploaded before and matches some imminent proposal,
             * no fee is paid.
             *
             * The dispatch origin of this call must be _Signed_.
             *
             * - `encoded_proposal`: The preimage of a proposal.
             *
             * Emits `PreimageNoted`.
             *
             * Weight: `O(E)` with E size of `encoded_proposal` (protected by a required deposit).
             **/
            noteImminentPreimage: AugmentedSubmittable<(encodedProposal: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Same as `note_imminent_preimage` but origin is `OperationalPreimageOrigin`.
             **/
            noteImminentPreimageOperational: AugmentedSubmittable<(encodedProposal: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Register the preimage for an upcoming proposal. This doesn't require the proposal to be
             * in the dispatch queue but does require a deposit, returned once enacted.
             *
             * The dispatch origin of this call must be _Signed_.
             *
             * - `encoded_proposal`: The preimage of a proposal.
             *
             * Emits `PreimageNoted`.
             *
             * Weight: `O(E)` with E size of `encoded_proposal` (protected by a required deposit).
             **/
            notePreimage: AugmentedSubmittable<(encodedProposal: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Same as `note_preimage` but origin is `OperationalPreimageOrigin`.
             **/
            notePreimageOperational: AugmentedSubmittable<(encodedProposal: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Propose a sensitive action to be taken.
             *
             * The dispatch origin of this call must be _Signed_ and the sender must
             * have funds to cover the deposit.
             *
             * - `proposal_hash`: The hash of the proposal preimage.
             * - `value`: The amount of deposit (must be at least `MinimumDeposit`).
             *
             * Emits `Proposed`.
             *
             * Weight: `O(p)`
             **/
            propose: AugmentedSubmittable<(proposalHash: Hash | string | Uint8Array, value: Compact<BalanceOf> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash, Compact<BalanceOf>]>;
            /**
             * Remove an expired proposal preimage and collect the deposit.
             *
             * The dispatch origin of this call must be _Signed_.
             *
             * - `proposal_hash`: The preimage hash of a proposal.
             * - `proposal_length_upper_bound`: an upper bound on length of the proposal.
             * Extrinsic is weighted according to this value with no refund.
             *
             * This will only work after `VotingPeriod` blocks from the time that the preimage was
             * noted, if it's the same account doing it. If it's a different account, then it'll only
             * work an additional `EnactmentPeriod` later.
             *
             * Emits `PreimageReaped`.
             *
             * Weight: `O(D)` where D is length of proposal.
             **/
            reapPreimage: AugmentedSubmittable<(proposalHash: Hash | string | Uint8Array, proposalLenUpperBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash, Compact<u32>]>;
            /**
             * Remove a vote for a referendum.
             *
             * If the `target` is equal to the signer, then this function is exactly equivalent to
             * `remove_vote`. If not equal to the signer, then the vote must have expired,
             * either because the referendum was cancelled, because the voter lost the referendum or
             * because the conviction period is over.
             *
             * The dispatch origin of this call must be _Signed_.
             *
             * - `target`: The account of the vote to be removed; this account must have voted for
             * referendum `index`.
             * - `index`: The index of referendum of the vote to be removed.
             *
             * Weight: `O(R + log R)` where R is the number of referenda that `target` has voted on.
             * Weight is calculated for the maximum number of vote.
             **/
            removeOtherVote: AugmentedSubmittable<(target: AccountId | string | Uint8Array, index: ReferendumIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, ReferendumIndex]>;
            /**
             * Remove a vote for a referendum.
             *
             * If:
             * - the referendum was cancelled, or
             * - the referendum is ongoing, or
             * - the referendum has ended such that
             * - the vote of the account was in opposition to the result; or
             * - there was no conviction to the account's vote; or
             * - the account made a split vote
             * ...then the vote is removed cleanly and a following call to `unlock` may result in more
             * funds being available.
             *
             * If, however, the referendum has ended and:
             * - it finished corresponding to the vote of the account, and
             * - the account made a standard vote with conviction, and
             * - the lock period of the conviction is not over
             * ...then the lock will be aggregated into the overall account's lock, which may involve
             * *overlocking* (where the two locks are combined into a single lock that is the maximum
             * of both the amount locked and the time is it locked for).
             *
             * The dispatch origin of this call must be _Signed_, and the signer must have a vote
             * registered for referendum `index`.
             *
             * - `index`: The index of referendum of the vote to be removed.
             *
             * Weight: `O(R + log R)` where R is the number of referenda that `target` has voted on.
             * Weight is calculated for the maximum number of vote.
             **/
            removeVote: AugmentedSubmittable<(index: ReferendumIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [ReferendumIndex]>;
            /**
             * Signals agreement with a particular proposal.
             *
             * The dispatch origin of this call must be _Signed_ and the sender
             * must have funds to cover the deposit, equal to the original deposit.
             *
             * - `proposal`: The index of the proposal to second.
             * - `seconds_upper_bound`: an upper bound on the current number of seconds on this
             * proposal. Extrinsic is weighted according to this value with no refund.
             *
             * Weight: `O(S)` where S is the number of seconds a proposal already has.
             **/
            second: AugmentedSubmittable<(proposal: Compact<PropIndex> | AnyNumber | Uint8Array, secondsUpperBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<PropIndex>, Compact<u32>]>;
            /**
             * Undelegate the voting power of the sending account.
             *
             * Tokens may be unlocked following once an amount of time consistent with the lock period
             * of the conviction with which the delegation was issued.
             *
             * The dispatch origin of this call must be _Signed_ and the signing account must be
             * currently delegating.
             *
             * Emits `Undelegated`.
             *
             * Weight: `O(R)` where R is the number of referendums the voter delegating to has
             * voted on. Weight is charged as if maximum votes.
             **/
            undelegate: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Unlock tokens that have an expired lock.
             *
             * The dispatch origin of this call must be _Signed_.
             *
             * - `target`: The account to remove the lock on.
             *
             * Weight: `O(R)` with R number of vote of target.
             **/
            unlock: AugmentedSubmittable<(target: AccountId | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId]>;
            /**
             * Veto and blacklist the external proposal hash.
             *
             * The dispatch origin of this call must be `VetoOrigin`.
             *
             * - `proposal_hash`: The preimage hash of the proposal to veto and blacklist.
             *
             * Emits `Vetoed`.
             *
             * Weight: `O(V + log(V))` where V is number of `existing vetoers`
             **/
            vetoExternal: AugmentedSubmittable<(proposalHash: Hash | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash]>;
            /**
             * Vote in a referendum. If `vote.is_aye()`, the vote is to enact the proposal;
             * otherwise it is a vote to keep the status quo.
             *
             * The dispatch origin of this call must be _Signed_.
             *
             * - `ref_index`: The index of the referendum to vote for.
             * - `vote`: The vote configuration.
             *
             * Weight: `O(R)` where R is the number of referendums the voter has voted on.
             **/
            vote: AugmentedSubmittable<(refIndex: Compact<ReferendumIndex> | AnyNumber | Uint8Array, vote: AccountVote | {
                Standard: any;
            } | {
                Split: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<ReferendumIndex>, AccountVote]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        dynamicFee: {
            noteMinGasPriceTarget: AugmentedSubmittable<(target: U256 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [U256]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        electionProviderMultiPhase: {
            /**
             * Submit a solution for the unsigned phase.
             *
             * The dispatch origin fo this call must be __none__.
             *
             * This submission is checked on the fly. Moreover, this unsigned solution is only
             * validated when submitted to the pool from the **local** node. Effectively, this means
             * that only active validators can submit this transaction when authoring a block (similar
             * to an inherent).
             *
             * To prevent any incorrect solution (and thus wasted time/weight), this transaction will
             * panic if the solution submitted by the validator is invalid in any way, effectively
             * putting their authoring reward at risk.
             *
             * No deposit or reward is associated with this submission.
             **/
            submitUnsigned: AugmentedSubmittable<(solution: RawSolution | {
                compact?: any;
                score?: any;
                round?: any;
            } | string | Uint8Array, witness: SolutionOrSnapshotSize | {
                voters?: any;
                targets?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [RawSolution, SolutionOrSnapshotSize]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        ethereum: {
            /**
             * Transact an Ethereum transaction.
             **/
            transact: AugmentedSubmittable<(transaction: EthTransaction | {
                nonce?: any;
                gasPrice?: any;
                gasLimit?: any;
                action?: any;
                value?: any;
                input?: any;
                signature?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthTransaction]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        evm: {
            /**
             * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.
             **/
            call: AugmentedSubmittable<(source: H160 | string | Uint8Array, target: H160 | string | Uint8Array, input: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, gasPrice: U256 | AnyNumber | Uint8Array, nonce: Option<U256> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, H160, Bytes, U256, u64, U256, Option<U256>]>;
            /**
             * Issue an EVM create operation. This is similar to a contract creation transaction in
             * Ethereum.
             **/
            create: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, gasPrice: U256 | AnyNumber | Uint8Array, nonce: Option<U256> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes, U256, u64, U256, Option<U256>]>;
            /**
             * Issue an EVM create2 operation.
             **/
            create2: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, salt: H256 | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, gasPrice: U256 | AnyNumber | Uint8Array, nonce: Option<U256> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes, H256, U256, u64, U256, Option<U256>]>;
            /**
             * Withdraw balance from EVM into currency/balances pallet.
             **/
            withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: BalanceOf | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, BalanceOf]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        grandpa: {
            /**
             * Note that the current authority set of the GRANDPA finality gadget has
             * stalled. This will trigger a forced authority set change at the beginning
             * of the next session, to be enacted `delay` blocks after that. The delay
             * should be high enough to safely assume that the block signalling the
             * forced change will not be re-orged (e.g. 1000 blocks). The GRANDPA voters
             * will start the new authority set using the given finalized block as base.
             * Only callable by root.
             **/
            noteStalled: AugmentedSubmittable<(delay: BlockNumber | AnyNumber | Uint8Array, bestFinalizedBlockNumber: BlockNumber | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [BlockNumber, BlockNumber]>;
            /**
             * Report voter equivocation/misbehavior. This method will verify the
             * equivocation proof and validate the given key ownership proof
             * against the extracted offender. If both are valid, the offence
             * will be reported.
             **/
            reportEquivocation: AugmentedSubmittable<(equivocationProof: GrandpaEquivocationProof | {
                setId?: any;
                equivocation?: any;
            } | string | Uint8Array, keyOwnerProof: KeyOwnerProof | {
                session?: any;
                trieNodes?: any;
                validatorCount?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [GrandpaEquivocationProof, KeyOwnerProof]>;
            /**
             * Report voter equivocation/misbehavior. This method will verify the
             * equivocation proof and validate the given key ownership proof
             * against the extracted offender. If both are valid, the offence
             * will be reported.
             *
             * This extrinsic must be called unsigned and it is expected that only
             * block authors will call it (validated in `ValidateUnsigned`), as such
             * if the block author is defined it will be defined as the equivocation
             * reporter.
             **/
            reportEquivocationUnsigned: AugmentedSubmittable<(equivocationProof: GrandpaEquivocationProof | {
                setId?: any;
                equivocation?: any;
            } | string | Uint8Array, keyOwnerProof: KeyOwnerProof | {
                session?: any;
                trieNodes?: any;
                validatorCount?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [GrandpaEquivocationProof, KeyOwnerProof]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        identity: {
            /**
             * Add a registrar to the system.
             *
             * The dispatch origin for this call must be `T::RegistrarOrigin`.
             *
             * - `account`: the account of the registrar.
             *
             * Emits `RegistrarAdded` if successful.
             *
             * # <weight>
             * - `O(R)` where `R` registrar-count (governance-bounded and code-bounded).
             * - One storage mutation (codec `O(R)`).
             * - One event.
             * # </weight>
             **/
            addRegistrar: AugmentedSubmittable<(account: AccountId | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId]>;
            /**
             * Add the given account to the sender's subs.
             *
             * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated
             * to the sender.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have a registered
             * sub identity of `sub`.
             **/
            addSub: AugmentedSubmittable<(sub: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, data: Data | {
                None: any;
            } | {
                Raw: any;
            } | {
                BlakeTwo256: any;
            } | {
                Sha256: any;
            } | {
                Keccak256: any;
            } | {
                ShaThree256: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Data]>;
            /**
             * Cancel a previous request.
             *
             * Payment: A previously reserved deposit is returned on success.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have a
             * registered identity.
             *
             * - `reg_index`: The index of the registrar whose judgement is no longer requested.
             *
             * Emits `JudgementUnrequested` if successful.
             *
             * # <weight>
             * - `O(R + X)`.
             * - One balance-reserve operation.
             * - One storage mutation `O(R + X)`.
             * - One event
             * # </weight>
             **/
            cancelRequest: AugmentedSubmittable<(regIndex: RegistrarIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [RegistrarIndex]>;
            /**
             * Clear an account's identity info and all sub-accounts and return all deposits.
             *
             * Payment: All reserved balances on the account are returned.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have a registered
             * identity.
             *
             * Emits `IdentityCleared` if successful.
             *
             * # <weight>
             * - `O(R + S + X)`
             * - where `R` registrar-count (governance-bounded).
             * - where `S` subs-count (hard- and deposit-bounded).
             * - where `X` additional-field-count (deposit-bounded and code-bounded).
             * - One balance-unreserve operation.
             * - `2` storage reads and `S + 2` storage deletions.
             * - One event.
             * # </weight>
             **/
            clearIdentity: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Remove an account's identity and sub-account information and slash the deposits.
             *
             * Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled by
             * `Slash`. Verification request deposits are not returned; they should be cancelled
             * manually using `cancel_request`.
             *
             * The dispatch origin for this call must match `T::ForceOrigin`.
             *
             * - `target`: the account whose identity the judgement is upon. This must be an account
             * with a registered identity.
             *
             * Emits `IdentityKilled` if successful.
             *
             * # <weight>
             * - `O(R + S + X)`.
             * - One balance-reserve operation.
             * - `S + 2` storage mutations.
             * - One event.
             * # </weight>
             **/
            killIdentity: AugmentedSubmittable<(target: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource]>;
            /**
             * Provide a judgement for an account's identity.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must be the account
             * of the registrar whose index is `reg_index`.
             *
             * - `reg_index`: the index of the registrar whose judgement is being made.
             * - `target`: the account whose identity the judgement is upon. This must be an account
             * with a registered identity.
             * - `judgement`: the judgement of the registrar of index `reg_index` about `target`.
             *
             * Emits `JudgementGiven` if successful.
             *
             * # <weight>
             * - `O(R + X)`.
             * - One balance-transfer operation.
             * - Up to one account-lookup operation.
             * - Storage: 1 read `O(R)`, 1 mutate `O(R + X)`.
             * - One event.
             * # </weight>
             **/
            provideJudgement: AugmentedSubmittable<(regIndex: Compact<RegistrarIndex> | AnyNumber | Uint8Array, target: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, judgement: IdentityJudgement | {
                Unknown: any;
            } | {
                FeePaid: any;
            } | {
                Reasonable: any;
            } | {
                KnownGood: any;
            } | {
                OutOfDate: any;
            } | {
                LowQuality: any;
            } | {
                Erroneous: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<RegistrarIndex>, LookupSource, IdentityJudgement]>;
            /**
             * Remove the sender as a sub-account.
             *
             * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated
             * to the sender (*not* the original depositor).
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have a registered
             * super-identity.
             *
             * NOTE: This should not normally be used, but is provided in the case that the non-
             * controller of an account is maliciously registered as a sub-account.
             **/
            quitSub: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Remove the given account from the sender's subs.
             *
             * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated
             * to the sender.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have a registered
             * sub identity of `sub`.
             **/
            removeSub: AugmentedSubmittable<(sub: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource]>;
            /**
             * Alter the associated name of the given sub-account.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have a registered
             * sub identity of `sub`.
             **/
            renameSub: AugmentedSubmittable<(sub: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, data: Data | {
                None: any;
            } | {
                Raw: any;
            } | {
                BlakeTwo256: any;
            } | {
                Sha256: any;
            } | {
                Keccak256: any;
            } | {
                ShaThree256: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Data]>;
            /**
             * Request a judgement from a registrar.
             *
             * Payment: At most `max_fee` will be reserved for payment to the registrar if judgement
             * given.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have a
             * registered identity.
             *
             * - `reg_index`: The index of the registrar whose judgement is requested.
             * - `max_fee`: The maximum fee that may be paid. This should just be auto-populated as:
             *
             * ```nocompile
             * Self::registrars().get(reg_index).unwrap().fee
             * ```
             *
             * Emits `JudgementRequested` if successful.
             *
             * # <weight>
             * - `O(R + X)`.
             * - One balance-reserve operation.
             * - Storage: 1 read `O(R)`, 1 mutate `O(X + R)`.
             * - One event.
             * # </weight>
             **/
            requestJudgement: AugmentedSubmittable<(regIndex: Compact<RegistrarIndex> | AnyNumber | Uint8Array, maxFee: Compact<BalanceOf> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<RegistrarIndex>, Compact<BalanceOf>]>;
            /**
             * Change the account associated with a registrar.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must be the account
             * of the registrar whose index is `index`.
             *
             * - `index`: the index of the registrar whose fee is to be set.
             * - `new`: the new account ID.
             *
             * # <weight>
             * - `O(R)`.
             * - One storage mutation `O(R)`.
             * - Benchmark: 8.823 + R * 0.32 µs (min squares analysis)
             * # </weight>
             **/
            setAccountId: AugmentedSubmittable<(index: Compact<RegistrarIndex> | AnyNumber | Uint8Array, updated: AccountId | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<RegistrarIndex>, AccountId]>;
            /**
             * Set the fee required for a judgement to be requested from a registrar.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must be the account
             * of the registrar whose index is `index`.
             *
             * - `index`: the index of the registrar whose fee is to be set.
             * - `fee`: the new fee.
             *
             * # <weight>
             * - `O(R)`.
             * - One storage mutation `O(R)`.
             * - Benchmark: 7.315 + R * 0.329 µs (min squares analysis)
             * # </weight>
             **/
            setFee: AugmentedSubmittable<(index: Compact<RegistrarIndex> | AnyNumber | Uint8Array, fee: Compact<BalanceOf> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<RegistrarIndex>, Compact<BalanceOf>]>;
            /**
             * Set the field information for a registrar.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must be the account
             * of the registrar whose index is `index`.
             *
             * - `index`: the index of the registrar whose fee is to be set.
             * - `fields`: the fields that the registrar concerns themselves with.
             *
             * # <weight>
             * - `O(R)`.
             * - One storage mutation `O(R)`.
             * - Benchmark: 7.464 + R * 0.325 µs (min squares analysis)
             * # </weight>
             **/
            setFields: AugmentedSubmittable<(index: Compact<RegistrarIndex> | AnyNumber | Uint8Array, fields: IdentityFields) => SubmittableExtrinsic<ApiType>, [Compact<RegistrarIndex>, IdentityFields]>;
            /**
             * Set an account's identity information and reserve the appropriate deposit.
             *
             * If the account already has identity information, the deposit is taken as part payment
             * for the new deposit.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * - `info`: The identity information.
             *
             * Emits `IdentitySet` if successful.
             *
             * # <weight>
             * - `O(X + X' + R)`
             * - where `X` additional-field-count (deposit-bounded and code-bounded)
             * - where `R` judgements-count (registrar-count-bounded)
             * - One balance reserve operation.
             * - One storage mutation (codec-read `O(X' + R)`, codec-write `O(X + R)`).
             * - One event.
             * # </weight>
             **/
            setIdentity: AugmentedSubmittable<(info: IdentityInfo | {
                additional?: any;
                display?: any;
                legal?: any;
                web?: any;
                riot?: any;
                email?: any;
                pgpFingerprint?: any;
                image?: any;
                twitter?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [IdentityInfo]>;
            /**
             * Set the sub-accounts of the sender.
             *
             * Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned
             * and an amount `SubAccountDeposit` will be reserved for each item in `subs`.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have a registered
             * identity.
             *
             * - `subs`: The identity's (new) sub-accounts.
             *
             * # <weight>
             * - `O(P + S)`
             * - where `P` old-subs-count (hard- and deposit-bounded).
             * - where `S` subs-count (hard- and deposit-bounded).
             * - At most one balance operations.
             * - DB:
             * - `P + S` storage mutations (codec complexity `O(1)`)
             * - One storage read (codec complexity `O(P)`).
             * - One storage write (codec complexity `O(S)`).
             * - One storage-exists (`IdentityOf::contains_key`).
             * # </weight>
             **/
            setSubs: AugmentedSubmittable<(subs: Vec<ITuple<[AccountId, Data]>> | ([AccountId | string | Uint8Array, Data | {
                None: any;
            } | {
                Raw: any;
            } | {
                BlakeTwo256: any;
            } | {
                Sha256: any;
            } | {
                Keccak256: any;
            } | {
                ShaThree256: any;
            } | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[AccountId, Data]>>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        imOnline: {
            /**
             * # <weight>
             * - Complexity: `O(K + E)` where K is length of `Keys` (heartbeat.validators_len)
             * and E is length of `heartbeat.network_state.external_address`
             * - `O(K)`: decoding of length `K`
             * - `O(E)`: decoding/encoding of length `E`
             * - DbReads: pallet_session `Validators`, pallet_session `CurrentIndex`, `Keys`,
             * `ReceivedHeartbeats`
             * - DbWrites: `ReceivedHeartbeats`
             * # </weight>
             **/
            heartbeat: AugmentedSubmittable<(heartbeat: Heartbeat | {
                blockNumber?: any;
                networkState?: any;
                sessionIndex?: any;
                authorityIndex?: any;
                validatorsLen?: any;
            } | string | Uint8Array, signature: Signature | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Heartbeat, Signature]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        indices: {
            /**
             * Assign an previously unassigned index.
             *
             * Payment: `Deposit` is reserved from the sender account.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * - `index`: the index to be claimed. This must not be in use.
             *
             * Emits `IndexAssigned` if successful.
             *
             * # <weight>
             * - `O(1)`.
             * - One storage mutation (codec `O(1)`).
             * - One reserve operation.
             * - One event.
             * -------------------
             * - DB Weight: 1 Read/Write (Accounts)
             * # </weight>
             **/
            claim: AugmentedSubmittable<(index: AccountIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountIndex]>;
            /**
             * Force an index to an account. This doesn't require a deposit. If the index is already
             * held, then any deposit is reimbursed to its current owner.
             *
             * The dispatch origin for this call must be _Root_.
             *
             * - `index`: the index to be (re-)assigned.
             * - `new`: the new owner of the index. This function is a no-op if it is equal to sender.
             * - `freeze`: if set to `true`, will freeze the index so it cannot be transferred.
             *
             * Emits `IndexAssigned` if successful.
             *
             * # <weight>
             * - `O(1)`.
             * - One storage mutation (codec `O(1)`).
             * - Up to one reserve operation.
             * - One event.
             * -------------------
             * - DB Weight:
             * - Reads: Indices Accounts, System Account (original owner)
             * - Writes: Indices Accounts, System Account (original owner)
             * # </weight>
             **/
            forceTransfer: AugmentedSubmittable<(updated: AccountId | string | Uint8Array, index: AccountIndex | AnyNumber | Uint8Array, freeze: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, AccountIndex, bool]>;
            /**
             * Free up an index owned by the sender.
             *
             * Payment: Any previous deposit placed for the index is unreserved in the sender account.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must own the index.
             *
             * - `index`: the index to be freed. This must be owned by the sender.
             *
             * Emits `IndexFreed` if successful.
             *
             * # <weight>
             * - `O(1)`.
             * - One storage mutation (codec `O(1)`).
             * - One reserve operation.
             * - One event.
             * -------------------
             * - DB Weight: 1 Read/Write (Accounts)
             * # </weight>
             **/
            free: AugmentedSubmittable<(index: AccountIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountIndex]>;
            /**
             * Freeze an index so it will always point to the sender account. This consumes the deposit.
             *
             * The dispatch origin for this call must be _Signed_ and the signing account must have a
             * non-frozen account `index`.
             *
             * - `index`: the index to be frozen in place.
             *
             * Emits `IndexFrozen` if successful.
             *
             * # <weight>
             * - `O(1)`.
             * - One storage mutation (codec `O(1)`).
             * - Up to one slash operation.
             * - One event.
             * -------------------
             * - DB Weight: 1 Read/Write (Accounts)
             * # </weight>
             **/
            freeze: AugmentedSubmittable<(index: AccountIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountIndex]>;
            /**
             * Assign an index already owned by the sender to another account. The balance reservation
             * is effectively transferred to the new account.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * - `index`: the index to be re-assigned. This must be owned by the sender.
             * - `new`: the new owner of the index. This function is a no-op if it is equal to sender.
             *
             * Emits `IndexAssigned` if successful.
             *
             * # <weight>
             * - `O(1)`.
             * - One storage mutation (codec `O(1)`).
             * - One transfer operation.
             * - One event.
             * -------------------
             * - DB Weight:
             * - Reads: Indices Accounts, System Account (recipient)
             * - Writes: Indices Accounts, System Account (recipient)
             * # </weight>
             **/
            transfer: AugmentedSubmittable<(updated: AccountId | string | Uint8Array, index: AccountIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, AccountIndex]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        merkle: {
            /**
             * Adds an array of leaf data into the tree and adds calculated root to
             * the cache.
             *
             * Can only be called by the manager if a manager is set.
             *
             * Weights:
             * - Dependent on argument: `members`
             *
             * - Base weight: 384_629_956_000
             * - DB weights: 3 reads, 2 writes
             * - Additional weights: 20_135_984_000 * members.len()
             **/
            addMembers: AugmentedSubmittable<(treeId: TreeId | AnyNumber | Uint8Array, members: Vec<ScalarData> | (ScalarData | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [TreeId, Vec<ScalarData>]>;
            /**
             * Creates a new tree and sets a new manager for that tree. The
             * initial manager is the sender. Also increments the mixer id counter
             * in the storage. If _depth is not provided, max tree depth is
             * assumed.
             *
             * Weights:
             * - Dependent on arguments: _depth
             *
             * - Base weight: 8_356_000
             * - DB weights: 1 read, 3 writes
             * - Additional weights: 151_000 * _depth
             **/
            createTree: AugmentedSubmittable<(rIsMgr: bool | boolean | Uint8Array, depth: Option<u8> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [bool, Option<u8>]>;
            /**
             * Sets manager account id.
             *
             * Can only be called by the root or the current manager.
             *
             * Weights:
             * - Independent of the arguments.
             *
             * - Base weight: 8_000_000
             * - DB weights: 1 read, 1 write
             **/
            setManager: AugmentedSubmittable<(treeId: TreeId | AnyNumber | Uint8Array, newManager: AccountId | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [TreeId, AccountId]>;
            /**
             * Sets if a manager is required for specific actions like adding
             * nullifiers or leaves into the tree.
             *
             * Can only be called by the root or the current manager.
             *
             * Weights:
             * - Independend of the arguments.
             *
             * - Base weight: 7_000_000
             * - DB weights: 1 read, 1 write
             **/
            setManagerRequired: AugmentedSubmittable<(treeId: TreeId | AnyNumber | Uint8Array, managerRequired: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [TreeId, bool]>;
            /**
             * Set stopped flag inside the storage.
             *
             * Can only be called by the root or the current manager.
             *
             * Weights:
             * - Independent of the arguments.
             *
             * - Base weight: 8_000_000
             * - DB weights: 1 read, 1 write
             **/
            setStopped: AugmentedSubmittable<(treeId: TreeId | AnyNumber | Uint8Array, stopped: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [TreeId, bool]>;
            /**
             * Verification stub for testing, these verification functions should
             * not need to be used directly as extrinsics. Rather, higher-order
             * modules should use the module functions to verify and execute
             * further logic.
             *
             * Verifies the membership proof.
             *
             * Weights:
             * - Dependent on the argument: `path`
             * - Base weight: 383_420_867_000
             * - DB weights: 1 read
             * - Additional weights: 814_291_000 * path.len()
             **/
            verify: AugmentedSubmittable<(treeId: TreeId | AnyNumber | Uint8Array, leaf: ScalarData | string | Uint8Array, path: Vec<ITuple<[bool, ScalarData]>> | ([bool | boolean | Uint8Array, ScalarData | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [TreeId, ScalarData, Vec<ITuple<[bool, ScalarData]>>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        mixer: {
            createNew: AugmentedSubmittable<(currencyId: CurrencyIdOf | AnyNumber | Uint8Array, size: BalanceOf | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [CurrencyIdOf, BalanceOf]>;
            /**
             * Deposits the fixed amount into the mixer with id of `mixer_id`
             * Multiple deposits can be inserted together since `data_points` is an
             * array.
             *
             * Fails in case the mixer is stopped or not initialized.
             *
             * Weights:
             * - Dependent on argument: `data_points`
             *
             * - Base weight: 417_168_400_000
             * - DB weights: 8 reads, 5 writes
             * - Additional weights: 21_400_442_000 * data_points.len()
             **/
            deposit: AugmentedSubmittable<(mixerId: TreeId | AnyNumber | Uint8Array, dataPoints: Vec<ScalarData> | (ScalarData | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [TreeId, Vec<ScalarData>]>;
            /**
             * Stops the operation of all the mixers managed by the pallet.
             * Can only be called by the admin or the root origin.
             *
             * Weights:
             * - Independent of the arguments.
             *
             * - Base weight: 36_000_000
             * - DB weights: 6 reads, 4 writes
             **/
            setStopped: AugmentedSubmittable<(stopped: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [bool]>;
            /**
             * Transfers the admin from the caller to the specified `to` account.
             * Can only be called by the current admin or the root origin.
             *
             * Weights:
             * - Independent of the arguments.
             *
             * - Base weight: 7_000_000
             * - DB weights: 1 read, 1 write
             **/
            transferAdmin: AugmentedSubmittable<(to: AccountId | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId]>;
            /**
             * Withdraws a deposited amount from the mixer. Can only withdraw one
             * deposit. Accepts proof of membership along with the mixer id.
             *
             * Fails if the mixer is stopped or not initialized.
             *
             * Weights:
             * - Independent of the arguments.
             *
             * - Base weight: 1_078_562_000_000
             * - DB weights: 9 reads, 3 writes
             **/
            withdraw: AugmentedSubmittable<(withdrawProof: WithdrawProof | {
                mixer_id?: any;
                cached_block?: any;
                cached_root?: any;
                comms?: any;
                nullifier_hash?: any;
                proof_bytes?: any;
                leaf_index_commitments?: any;
                proof_commitments?: any;
                recipient?: any;
                relayer?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [WithdrawProof]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        multisig: {
            /**
             * Register approval for a dispatch to be made from a deterministic composite account if
             * approved by a total of `threshold - 1` of `other_signatories`.
             *
             * Payment: `DepositBase` will be reserved if this is the first approval, plus
             * `threshold` times `DepositFactor`. It is returned once this dispatch happens or
             * is cancelled.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * - `threshold`: The total number of approvals for this dispatch before it is executed.
             * - `other_signatories`: The accounts (other than the sender) who can approve this
             * dispatch. May not be empty.
             * - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is
             * not the first approval, then it must be `Some`, with the timepoint (block number and
             * transaction index) of the first approval transaction.
             * - `call_hash`: The hash of the call to be executed.
             *
             * NOTE: If this is the final approval, you will want to use `as_multi` instead.
             *
             * # <weight>
             * - `O(S)`.
             * - Up to one balance-reserve or unreserve operation.
             * - One passthrough operation, one insert, both `O(S)` where `S` is the number of
             * signatories. `S` is capped by `MaxSignatories`, with weight being proportional.
             * - One encode & hash, both of complexity `O(S)`.
             * - Up to one binary search and insert (`O(logS + S)`).
             * - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove.
             * - One event.
             * - Storage: inserts one item, value size bounded by `MaxSignatories`, with a
             * deposit taken for its lifetime of
             * `DepositBase + threshold * DepositFactor`.
             * ----------------------------------
             * - DB Weight:
             * - Read: Multisig Storage, [Caller Account]
             * - Write: Multisig Storage, [Caller Account]
             * # </weight>
             **/
            approveAsMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec<AccountId> | (AccountId | string | Uint8Array)[], maybeTimepoint: Option<Timepoint> | null | object | string | Uint8Array, callHash: U8aFixed | string | Uint8Array, maxWeight: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Vec<AccountId>, Option<Timepoint>, U8aFixed, Weight]>;
            /**
             * Register approval for a dispatch to be made from a deterministic composite account if
             * approved by a total of `threshold - 1` of `other_signatories`.
             *
             * If there are enough, then dispatch the call.
             *
             * Payment: `DepositBase` will be reserved if this is the first approval, plus
             * `threshold` times `DepositFactor`. It is returned once this dispatch happens or
             * is cancelled.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * - `threshold`: The total number of approvals for this dispatch before it is executed.
             * - `other_signatories`: The accounts (other than the sender) who can approve this
             * dispatch. May not be empty.
             * - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is
             * not the first approval, then it must be `Some`, with the timepoint (block number and
             * transaction index) of the first approval transaction.
             * - `call`: The call to be executed.
             *
             * NOTE: Unless this is the final approval, you will generally want to use
             * `approve_as_multi` instead, since it only requires a hash of the call.
             *
             * Result is equivalent to the dispatched result if `threshold` is exactly `1`. Otherwise
             * on success, result is `Ok` and the result from the interior call, if it was executed,
             * may be found in the deposited `MultisigExecuted` event.
             *
             * # <weight>
             * - `O(S + Z + Call)`.
             * - Up to one balance-reserve or unreserve operation.
             * - One passthrough operation, one insert, both `O(S)` where `S` is the number of
             * signatories. `S` is capped by `MaxSignatories`, with weight being proportional.
             * - One call encode & hash, both of complexity `O(Z)` where `Z` is tx-len.
             * - One encode & hash, both of complexity `O(S)`.
             * - Up to one binary search and insert (`O(logS + S)`).
             * - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove.
             * - One event.
             * - The weight of the `call`.
             * - Storage: inserts one item, value size bounded by `MaxSignatories`, with a
             * deposit taken for its lifetime of
             * `DepositBase + threshold * DepositFactor`.
             * -------------------------------
             * - DB Weight:
             * - Reads: Multisig Storage, [Caller Account], Calls (if `store_call`)
             * - Writes: Multisig Storage, [Caller Account], Calls (if `store_call`)
             * - Plus Call Weight
             * # </weight>
             **/
            asMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec<AccountId> | (AccountId | string | Uint8Array)[], maybeTimepoint: Option<Timepoint> | null | object | string | Uint8Array, call: OpaqueCall | string | Uint8Array, storeCall: bool | boolean | Uint8Array, maxWeight: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Vec<AccountId>, Option<Timepoint>, OpaqueCall, bool, Weight]>;
            /**
             * Immediately dispatch a multi-signature call using a single approval from the caller.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * - `other_signatories`: The accounts (other than the sender) who are part of the
             * multi-signature, but do not participate in the approval process.
             * - `call`: The call to be executed.
             *
             * Result is equivalent to the dispatched result.
             *
             * # <weight>
             * O(Z + C) where Z is the length of the call and C its execution weight.
             * -------------------------------
             * - DB Weight: None
             * - Plus Call Weight
             * # </weight>
             **/
            asMultiThreshold1: AugmentedSubmittable<(otherSignatories: Vec<AccountId> | (AccountId | string | Uint8Array)[], call: Call | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<AccountId>, Call]>;
            /**
             * Cancel a pre-existing, on-going multisig transaction. Any deposit reserved previously
             * for this operation will be unreserved on success.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * - `threshold`: The total number of approvals for this dispatch before it is executed.
             * - `other_signatories`: The accounts (other than the sender) who can approve this
             * dispatch. May not be empty.
             * - `timepoint`: The timepoint (block number and transaction index) of the first approval
             * transaction for this dispatch.
             * - `call_hash`: The hash of the call to be executed.
             *
             * # <weight>
             * - `O(S)`.
             * - Up to one balance-reserve or unreserve operation.
             * - One passthrough operation, one insert, both `O(S)` where `S` is the number of
             * signatories. `S` is capped by `MaxSignatories`, with weight being proportional.
             * - One encode & hash, both of complexity `O(S)`.
             * - One event.
             * - I/O: 1 read `O(S)`, one remove.
             * - Storage: removes one item.
             * ----------------------------------
             * - DB Weight:
             * - Read: Multisig Storage, [Caller Account], Refund Account, Calls
             * - Write: Multisig Storage, [Caller Account], Refund Account, Calls
             * # </weight>
             **/
            cancelAsMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec<AccountId> | (AccountId | string | Uint8Array)[], timepoint: Timepoint | {
                height?: any;
                index?: any;
            } | string | Uint8Array, callHash: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Vec<AccountId>, Timepoint, U8aFixed]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        nft: {
            /**
             * Burn NFT token
             *
             * - `token`: (class_id, token_id)
             **/
            burn: AugmentedSubmittable<(token: ITuple<[ClassIdOf, TokenIdOf]> | [ClassIdOf | AnyNumber | Uint8Array, TokenIdOf | AnyNumber | Uint8Array]) => SubmittableExtrinsic<ApiType>, [ITuple<[ClassIdOf, TokenIdOf]>]>;
            /**
             * Burn NFT token
             *
             * - `token`: (class_id, token_id)
             * - `remark`: Vec<u8>
             **/
            burnWithRemark: AugmentedSubmittable<(token: ITuple<[ClassIdOf, TokenIdOf]> | [ClassIdOf | AnyNumber | Uint8Array, TokenIdOf | AnyNumber | Uint8Array], remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [ITuple<[ClassIdOf, TokenIdOf]>, Bytes]>;
            /**
             * Create NFT class, tokens belong to the class.
             *
             * - `metadata`: external metadata
             * - `properties`: class property, include `Transferable` `Burnable`
             **/
            createClass: AugmentedSubmittable<(metadata: CID | string | Uint8Array, properties: Properties) => SubmittableExtrinsic<ApiType>, [CID, Properties]>;
            /**
             * Destroy NFT class, remove dest from proxy, and send all the free
             * balance to dest
             *
             * - `class_id`: The class ID to destroy
             * - `dest`: The proxy account that will receive free balance
             **/
            destroyClass: AugmentedSubmittable<(classId: ClassIdOf | AnyNumber | Uint8Array, dest: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [ClassIdOf, LookupSource]>;
            /**
             * Mint NFT token
             *
             * - `to`: the token owner's account
             * - `class_id`: token belong to the class id
             * - `metadata`: external metadata
             * - `quantity`: token quantity
             **/
            mint: AugmentedSubmittable<(to: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, classId: ClassIdOf | AnyNumber | Uint8Array, metadata: CID | string | Uint8Array, quantity: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, ClassIdOf, CID, u32]>;
            /**
             * Transfer NFT token to another account
             *
             * - `to`: the token owner's account
             * - `token`: (class_id, token_id)
             **/
            transfer: AugmentedSubmittable<(to: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, token: ITuple<[ClassIdOf, TokenIdOf]> | [ClassIdOf | AnyNumber | Uint8Array, TokenIdOf | AnyNumber | Uint8Array]) => SubmittableExtrinsic<ApiType>, [LookupSource, ITuple<[ClassIdOf, TokenIdOf]>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        phragmenElection: {
            /**
             * Clean all voters who are defunct (i.e. they do not serve any purpose at all). The
             * deposit of the removed voters are returned.
             *
             * This is an root function to be used only for cleaning the state.
             *
             * The dispatch origin of this call must be root.
             *
             * # <weight>
             * The total number of voters and those that are defunct must be provided as witness data.
             * # </weight>
             **/
            cleanDefunctVoters: AugmentedSubmittable<(numVoters: u32 | AnyNumber | Uint8Array, numDefunct: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;
            /**
             * Remove a particular member from the set. This is effective immediately and the bond of
             * the outgoing member is slashed.
             *
             * If a runner-up is available, then the best runner-up will be removed and replaces the
             * outgoing member. Otherwise, a new phragmen election is started.
             *
             * The dispatch origin of this call must be root.
             *
             * Note that this does not affect the designated block number of the next election.
             *
             * # <weight>
             * If we have a replacement, we use a small weight. Else, since this is a root call and
             * will go into phragmen, we assume full block for now.
             * # </weight>
             **/
            removeMember: AugmentedSubmittable<(who: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, hasReplacement: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, bool]>;
            /**
             * Remove `origin` as a voter.
             *
             * This removes the lock and returns the deposit.
             *
             * The dispatch origin of this call must be signed and be a voter.
             **/
            removeVoter: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Renounce one's intention to be a candidate for the next election round. 3 potential
             * outcomes exist:
             *
             * - `origin` is a candidate and not elected in any set. In this case, the deposit is
             * unreserved, returned and origin is removed as a candidate.
             * - `origin` is a current runner-up. In this case, the deposit is unreserved, returned and
             * origin is removed as a runner-up.
             * - `origin` is a current member. In this case, the deposit is unreserved and origin is
             * removed as a member, consequently not being a candidate for the next round anymore.
             * Similar to [`remove_members`], if replacement runners exists, they are immediately
             * used. If the prime is renouncing, then no prime will exist until the next round.
             *
             * The dispatch origin of this call must be signed, and have one of the above roles.
             *
             * # <weight>
             * The type of renouncing must be provided as witness data.
             * # </weight>
             **/
            renounceCandidacy: AugmentedSubmittable<(renouncing: Renouncing | {
                Member: any;
            } | {
                RunnerUp: any;
            } | {
                Candidate: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Renouncing]>;
            /**
             * Submit oneself for candidacy. A fixed amount of deposit is recorded.
             *
             * All candidates are wiped at the end of the term. They either become a member/runner-up,
             * or leave the system while their deposit is slashed.
             *
             * The dispatch origin of this call must be signed.
             *
             * ### Warning
             *
             * Even if a candidate ends up being a member, they must call [`Call::renounce_candidacy`]
             * to get their deposit back. Losing the spot in an election will always lead to a slash.
             *
             * # <weight>
             * The number of current candidates must be provided as witness data.
             * # </weight>
             **/
            submitCandidacy: AugmentedSubmittable<(candidateCount: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
            /**
             * Vote for a set of candidates for the upcoming round of election. This can be called to
             * set the initial votes, or update already existing votes.
             *
             * Upon initial voting, `value` units of `who`'s balance is locked and a deposit amount is
             * reserved. The deposit is based on the number of votes and can be updated over time.
             *
             * The `votes` should:
             * - not be empty.
             * - be less than the number of possible candidates. Note that all current members and
             * runners-up are also automatically candidates for the next round.
             *
             * If `value` is more than `who`'s total balance, then the maximum of the two is used.
             *
             * The dispatch origin of this call must be signed.
             *
             * ### Warning
             *
             * It is the responsibility of the caller to **NOT** place all of their balance into the
             * lock and keep some for further operations.
             *
             * # <weight>
             * We assume the maximum weight among all 3 cases: vote_equal, vote_more and vote_less.
             * # </weight>
             **/
            vote: AugmentedSubmittable<(votes: Vec<AccountId> | (AccountId | string | Uint8Array)[], value: Compact<BalanceOf> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<AccountId>, Compact<BalanceOf>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        proxy: {
            /**
             * Register a proxy account for the sender that is able to make calls on its behalf.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * Parameters:
             * - `proxy`: The account that the `caller` would like to make a proxy.
             * - `proxy_type`: The permissions allowed for this proxy account.
             * - `delay`: The announcement period required of the initial proxy. Will generally be
             * zero.
             *
             * # <weight>
             * Weight is a function of the number of proxies the user has (P).
             * # </weight>
             **/
            addProxy: AugmentedSubmittable<(delegate: AccountId | string | Uint8Array, proxyType: ProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | number | Uint8Array, delay: BlockNumber | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, ProxyType, BlockNumber]>;
            /**
             * Publish the hash of a proxy-call that will be made in the future.
             *
             * This must be called some number of blocks before the corresponding `proxy` is attempted
             * if the delay associated with the proxy relationship is greater than zero.
             *
             * No more than `MaxPending` announcements may be made at any one time.
             *
             * This will take a deposit of `AnnouncementDepositFactor` as well as
             * `AnnouncementDepositBase` if there are no other pending announcements.
             *
             * The dispatch origin for this call must be _Signed_ and a proxy of `real`.
             *
             * Parameters:
             * - `real`: The account that the proxy will make a call on behalf of.
             * - `call_hash`: The hash of the call to be made by the `real` account.
             *
             * # <weight>
             * Weight is a function of:
             * - A: the number of announcements made.
             * - P: the number of proxies the user has.
             * # </weight>
             **/
            announce: AugmentedSubmittable<(real: AccountId | string | Uint8Array, callHash: CallHashOf | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, CallHashOf]>;
            /**
             * Spawn a fresh new account that is guaranteed to be otherwise inaccessible, and
             * initialize it with a proxy of `proxy_type` for `origin` sender.
             *
             * Requires a `Signed` origin.
             *
             * - `proxy_type`: The type of the proxy that the sender will be registered as over the
             * new account. This will almost always be the most permissive `ProxyType` possible to
             * allow for maximum flexibility.
             * - `index`: A disambiguation index, in case this is called multiple times in the same
             * transaction (e.g. with `utility::batch`). Unless you're using `batch` you probably just
             * want to use `0`.
             * - `delay`: The announcement period required of the initial proxy. Will generally be
             * zero.
             *
             * Fails with `Duplicate` if this has already been called in this transaction, from the
             * same sender, with the same parameters.
             *
             * Fails if there are insufficient funds to pay for deposit.
             *
             * # <weight>
             * Weight is a function of the number of proxies the user has (P).
             * # </weight>
             * TODO: Might be over counting 1 read
             **/
            anonymous: AugmentedSubmittable<(proxyType: ProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | number | Uint8Array, delay: BlockNumber | AnyNumber | Uint8Array, index: u16 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [ProxyType, BlockNumber, u16]>;
            /**
             * Removes a previously spawned anonymous proxy.
             *
             * WARNING: **All access to this account will be lost.** Any funds held in it will be
             * inaccessible.
             *
             * Requires a `Signed` origin, and the sender account must have been created by a call to
             * `anonymous` with corresponding parameters.
             *
             * - `spawner`: The account that originally called `anonymous` to create this account.
             * - `index`: The disambiguation index originally passed to `anonymous`. Probably `0`.
             * - `proxy_type`: The proxy type originally passed to `anonymous`.
             * - `height`: The height of the chain when the call to `anonymous` was processed.
             * - `ext_index`: The extrinsic index in which the call to `anonymous` was processed.
             *
             * Fails with `NoPermission` in case the caller is not a previously created anonymous
             * account whose `anonymous` call has corresponding parameters.
             *
             * # <weight>
             * Weight is a function of the number of proxies the user has (P).
             * # </weight>
             **/
            killAnonymous: AugmentedSubmittable<(spawner: AccountId | string | Uint8Array, proxyType: ProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | number | Uint8Array, index: u16 | AnyNumber | Uint8Array, height: Compact<BlockNumber> | AnyNumber | Uint8Array, extIndex: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, ProxyType, u16, Compact<BlockNumber>, Compact<u32>]>;
            /**
             * Dispatch the given `call` from an account that the sender is authorised for through
             * `add_proxy`.
             *
             * Removes any corresponding announcement(s).
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * Parameters:
             * - `real`: The account that the proxy will make a call on behalf of.
             * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
             * - `call`: The call to be made by the `real` account.
             *
             * # <weight>
             * Weight is a function of the number of proxies the user has (P).
             * # </weight>
             **/
            proxy: AugmentedSubmittable<(real: AccountId | string | Uint8Array, forceProxyType: Option<ProxyType> | null | object | string | Uint8Array, call: Call | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, Option<ProxyType>, Call]>;
            /**
             * Dispatch the given `call` from an account that the sender is authorized for through
             * `add_proxy`.
             *
             * Removes any corresponding announcement(s).
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * Parameters:
             * - `real`: The account that the proxy will make a call on behalf of.
             * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
             * - `call`: The call to be made by the `real` account.
             *
             * # <weight>
             * Weight is a function of:
             * - A: the number of announcements made.
             * - P: the number of proxies the user has.
             * # </weight>
             **/
            proxyAnnounced: AugmentedSubmittable<(delegate: AccountId | string | Uint8Array, real: AccountId | string | Uint8Array, forceProxyType: Option<ProxyType> | null | object | string | Uint8Array, call: Call | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, AccountId, Option<ProxyType>, Call]>;
            /**
             * Remove the given announcement of a delegate.
             *
             * May be called by a target (proxied) account to remove a call that one of their delegates
             * (`delegate`) has announced they want to execute. The deposit is returned.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * Parameters:
             * - `delegate`: The account that previously announced the call.
             * - `call_hash`: The hash of the call to be made.
             *
             * # <weight>
             * Weight is a function of:
             * - A: the number of announcements made.
             * - P: the number of proxies the user has.
             * # </weight>
             **/
            rejectAnnouncement: AugmentedSubmittable<(delegate: AccountId | string | Uint8Array, callHash: CallHashOf | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, CallHashOf]>;
            /**
             * Remove a given announcement.
             *
             * May be called by a proxy account to remove a call they previously announced and return
             * the deposit.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * Parameters:
             * - `real`: The account that the proxy will make a call on behalf of.
             * - `call_hash`: The hash of the call to be made by the `real` account.
             *
             * # <weight>
             * Weight is a function of:
             * - A: the number of announcements made.
             * - P: the number of proxies the user has.
             * # </weight>
             **/
            removeAnnouncement: AugmentedSubmittable<(real: AccountId | string | Uint8Array, callHash: CallHashOf | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, CallHashOf]>;
            /**
             * Unregister all proxy accounts for the sender.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * WARNING: This may be called on accounts created by `anonymous`, however if done, then
             * the unreserved fees will be inaccessible. **All access to this account will be lost.**
             *
             * # <weight>
             * Weight is a function of the number of proxies the user has (P).
             * # </weight>
             **/
            removeProxies: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Unregister a proxy account for the sender.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * Parameters:
             * - `proxy`: The account that the `caller` would like to remove as a proxy.
             * - `proxy_type`: The permissions currently enabled for the removed proxy account.
             *
             * # <weight>
             * Weight is a function of the number of proxies the user has (P).
             * # </weight>
             **/
            removeProxy: AugmentedSubmittable<(delegate: AccountId | string | Uint8Array, proxyType: ProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | number | Uint8Array, delay: BlockNumber | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, ProxyType, BlockNumber]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        recovery: {
            /**
             * Send a call through a recovered account.
             *
             * The dispatch origin for this call must be _Signed_ and registered to
             * be able to make calls on behalf of the recovered account.
             *
             * Parameters:
             * - `account`: The recovered account you want to make a call on-behalf-of.
             * - `call`: The call you want to make with the recovered account.
             *
             * # <weight>
             * - The weight of the `call` + 10,000.
             * - One storage lookup to check account is recovered by `who`. O(1)
             * # </weight>
             **/
            asRecovered: AugmentedSubmittable<(account: AccountId | string | Uint8Array, call: Call | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, Call]>;
            /**
             * Cancel the ability to use `as_recovered` for `account`.
             *
             * The dispatch origin for this call must be _Signed_ and registered to
             * be able to make calls on behalf of the recovered account.
             *
             * Parameters:
             * - `account`: The recovered account you are able to call on-behalf-of.
             *
             * # <weight>
             * - One storage mutation to check account is recovered by `who`. O(1)
             * # </weight>
             **/
            cancelRecovered: AugmentedSubmittable<(account: AccountId | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId]>;
            /**
             * Allow a successful rescuer to claim their recovered account.
             *
             * The dispatch origin for this call must be _Signed_ and must be a "rescuer"
             * who has successfully completed the account recovery process: collected
             * `threshold` or more vouches, waited `delay_period` blocks since initiation.
             *
             * Parameters:
             * - `account`: The lost account that you want to claim has been successfully
             * recovered by you.
             *
             * # <weight>
             * Key: F (len of friends in config), V (len of vouching friends)
             * - One storage read to get the recovery configuration. O(1), Codec O(F)
             * - One storage read to get the active recovery process. O(1), Codec O(V)
             * - One storage read to get the current block number. O(1)
             * - One storage write. O(1), Codec O(V).
             * - One event.
             *
             * Total Complexity: O(F + V)
             * # </weight>
             **/
            claimRecovery: AugmentedSubmittable<(account: AccountId | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId]>;
            /**
             * As the controller of a recoverable account, close an active recovery
             * process for your account.
             *
             * Payment: By calling this function, the recoverable account will receive
             * the recovery deposit `RecoveryDeposit` placed by the rescuer.
             *
             * The dispatch origin for this call must be _Signed_ and must be a
             * recoverable account with an active recovery process for it.
             *
             * Parameters:
             * - `rescuer`: The account trying to rescue this recoverable account.
             *
             * # <weight>
             * Key: V (len of vouching friends)
             * - One storage read/remove to get the active recovery process. O(1), Codec O(V)
             * - One balance call to repatriate reserved. O(X)
             * - One event.
             *
             * Total Complexity: O(V + X)
             * # </weight>
             **/
            closeRecovery: AugmentedSubmittable<(rescuer: AccountId | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId]>;
            /**
             * Create a recovery configuration for your account. This makes your account recoverable.
             *
             * Payment: `ConfigDepositBase` + `FriendDepositFactor` * #_of_friends balance
             * will be reserved for storing the recovery configuration. This deposit is returned
             * in full when the user calls `remove_recovery`.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * Parameters:
             * - `friends`: A list of friends you trust to vouch for recovery attempts.
             * Should be ordered and contain no duplicate values.
             * - `threshold`: The number of friends that must vouch for a recovery attempt
             * before the account can be recovered. Should be less than or equal to
             * the length of the list of friends.
             * - `delay_period`: The number of blocks after a recovery attempt is initialized
             * that needs to pass before the account can be recovered.
             *
             * # <weight>
             * - Key: F (len of friends)
             * - One storage read to check that account is not already recoverable. O(1).
             * - A check that the friends list is sorted and unique. O(F)
             * - One currency reserve operation. O(X)
             * - One storage write. O(1). Codec O(F).
             * - One event.
             *
             * Total Complexity: O(F + X)
             * # </weight>
             **/
            createRecovery: AugmentedSubmittable<(friends: Vec<AccountId> | (AccountId | string | Uint8Array)[], threshold: u16 | AnyNumber | Uint8Array, delayPeriod: BlockNumber | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<AccountId>, u16, BlockNumber]>;
            /**
             * Initiate the process for recovering a recoverable account.
             *
             * Payment: `RecoveryDeposit` balance will be reserved for initiating the
             * recovery process. This deposit will always be repatriated to the account
             * trying to be recovered. See `close_recovery`.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * Parameters:
             * - `account`: The lost account that you want to recover. This account
             * needs to be recoverable (i.e. have a recovery configuration).
             *
             * # <weight>
             * - One storage read to check that account is recoverable. O(F)
             * - One storage read to check that this recovery process hasn't already started. O(1)
             * - One currency reserve operation. O(X)
             * - One storage read to get the current block number. O(1)
             * - One storage write. O(1).
             * - One event.
             *
             * Total Complexity: O(F + X)
             * # </weight>
             **/
            initiateRecovery: AugmentedSubmittable<(account: AccountId | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId]>;
            /**
             * Remove the recovery process for your account. Recovered accounts are still accessible.
             *
             * NOTE: The user must make sure to call `close_recovery` on all active
             * recovery attempts before calling this function else it will fail.
             *
             * Payment: By calling this function the recoverable account will unreserve
             * their recovery configuration deposit.
             * (`ConfigDepositBase` + `FriendDepositFactor` * #_of_friends)
             *
             * The dispatch origin for this call must be _Signed_ and must be a
             * recoverable account (i.e. has a recovery configuration).
             *
             * # <weight>
             * Key: F (len of friends)
             * - One storage read to get the prefix iterator for active recoveries. O(1)
             * - One storage read/remove to get the recovery configuration. O(1), Codec O(F)
             * - One balance call to unreserved. O(X)
             * - One event.
             *
             * Total Complexity: O(F + X)
             * # </weight>
             **/
            removeRecovery: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Allow ROOT to bypass the recovery process and set an a rescuer account
             * for a lost account directly.
             *
             * The dispatch origin for this call must be _ROOT_.
             *
             * Parameters:
             * - `lost`: The "lost account" to be recovered.
             * - `rescuer`: The "rescuer account" which can call as the lost account.
             *
             * # <weight>
             * - One storage write O(1)
             * - One event
             * # </weight>
             **/
            setRecovered: AugmentedSubmittable<(lost: AccountId | string | Uint8Array, rescuer: AccountId | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, AccountId]>;
            /**
             * Allow a "friend" of a recoverable account to vouch for an active recovery
             * process for that account.
             *
             * The dispatch origin for this call must be _Signed_ and must be a "friend"
             * for the recoverable account.
             *
             * Parameters:
             * - `lost`: The lost account that you want to recover.
             * - `rescuer`: The account trying to rescue the lost account that you
             * want to vouch for.
             *
             * The combination of these two parameters must point to an active recovery
             * process.
             *
             * # <weight>
             * Key: F (len of friends in config), V (len of vouching friends)
             * - One storage read to get the recovery configuration. O(1), Codec O(F)
             * - One storage read to get the active recovery process. O(1), Codec O(V)
             * - One binary search to confirm caller is a friend. O(logF)
             * - One binary search to confirm caller has not already vouched. O(logV)
             * - One storage write. O(1), Codec O(V).
             * - One event.
             *
             * Total Complexity: O(F + logF + V + logV)
             * # </weight>
             **/
            vouchRecovery: AugmentedSubmittable<(lost: AccountId | string | Uint8Array, rescuer: AccountId | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, AccountId]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        scheduler: {
            /**
             * Cancel an anonymously scheduled task.
             *
             * # <weight>
             * - S = Number of already scheduled calls
             * - Base Weight: 22.15 + 2.869 * S µs
             * - DB Weight:
             * - Read: Agenda
             * - Write: Agenda, Lookup
             * - Will use base weight of 100 which should be good for up to 30 scheduled calls
             * # </weight>
             **/
            cancel: AugmentedSubmittable<(when: BlockNumber | AnyNumber | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [BlockNumber, u32]>;
            /**
             * Cancel a named scheduled task.
             *
             * # <weight>
             * - S = Number of already scheduled calls
             * - Base Weight: 24.91 + 2.907 * S µs
             * - DB Weight:
             * - Read: Agenda, Lookup
             * - Write: Agenda, Lookup
             * - Will use base weight of 100 which should be good for up to 30 scheduled calls
             * # </weight>
             **/
            cancelNamed: AugmentedSubmittable<(id: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Anonymously schedule a task.
             *
             * # <weight>
             * - S = Number of already scheduled calls
             * - Base Weight: 22.29 + .126 * S µs
             * - DB Weight:
             * - Read: Agenda
             * - Write: Agenda
             * - Will use base weight of 25 which should be good for up to 30 scheduled calls
             * # </weight>
             **/
            schedule: AugmentedSubmittable<(when: BlockNumber | AnyNumber | Uint8Array, maybePeriodic: Option<Period> | null | object | string | Uint8Array, priority: Priority | AnyNumber | Uint8Array, call: Call | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [BlockNumber, Option<Period>, Priority, Call]>;
            /**
             * Anonymously schedule a task after a delay.
             *
             * # <weight>
             * Same as [`schedule`].
             * # </weight>
             **/
            scheduleAfter: AugmentedSubmittable<(after: BlockNumber | AnyNumber | Uint8Array, maybePeriodic: Option<Period> | null | object | string | Uint8Array, priority: Priority | AnyNumber | Uint8Array, call: Call | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [BlockNumber, Option<Period>, Priority, Call]>;
            /**
             * Schedule a named task.
             *
             * # <weight>
             * - S = Number of already scheduled calls
             * - Base Weight: 29.6 + .159 * S µs
             * - DB Weight:
             * - Read: Agenda, Lookup
             * - Write: Agenda, Lookup
             * - Will use base weight of 35 which should be good for more than 30 scheduled calls
             * # </weight>
             **/
            scheduleNamed: AugmentedSubmittable<(id: Bytes | string | Uint8Array, when: BlockNumber | AnyNumber | Uint8Array, maybePeriodic: Option<Period> | null | object | string | Uint8Array, priority: Priority | AnyNumber | Uint8Array, call: Call | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, BlockNumber, Option<Period>, Priority, Call]>;
            /**
             * Schedule a named task after a delay.
             *
             * # <weight>
             * Same as [`schedule_named`].
             * # </weight>
             **/
            scheduleNamedAfter: AugmentedSubmittable<(id: Bytes | string | Uint8Array, after: BlockNumber | AnyNumber | Uint8Array, maybePeriodic: Option<Period> | null | object | string | Uint8Array, priority: Priority | AnyNumber | Uint8Array, call: Call | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, BlockNumber, Option<Period>, Priority, Call]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        session: {
            /**
             * Removes any session key(s) of the function caller.
             * This doesn't take effect until the next session.
             *
             * The dispatch origin of this function must be signed.
             *
             * # <weight>
             * - Complexity: `O(1)` in number of key types.
             * Actual cost depends on the number of length of `T::Keys::key_ids()` which is fixed.
             * - DbReads: `T::ValidatorIdOf`, `NextKeys`, `origin account`
             * - DbWrites: `NextKeys`, `origin account`
             * - DbWrites per key id: `KeyOwnder`
             * # </weight>
             **/
            purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Sets the session key(s) of the function caller to `keys`.
             * Allows an account to set its session key prior to becoming a validator.
             * This doesn't take effect until the next session.
             *
             * The dispatch origin of this function must be signed.
             *
             * # <weight>
             * - Complexity: `O(1)`
             * Actual cost depends on the number of length of `T::Keys::key_ids()` which is fixed.
             * - DbReads: `origin account`, `T::ValidatorIdOf`, `NextKeys`
             * - DbWrites: `origin account`, `NextKeys`
             * - DbReads per key id: `KeyOwner`
             * - DbWrites per key id: `KeyOwner`
             * # </weight>
             **/
            setKeys: AugmentedSubmittable<(keys: Keys, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Keys, Bytes]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        staking: {
            /**
             * Take the origin account as a stash and lock up `value` of its balance. `controller` will
             * be the account that controls it.
             *
             * `value` must be more than the `minimum_balance` specified by `T::Currency`.
             *
             * The dispatch origin for this call must be _Signed_ by the stash account.
             *
             * Emits `Bonded`.
             *
             * # <weight>
             * - Independent of the arguments. Moderate complexity.
             * - O(1).
             * - Three extra DB entries.
             *
             * NOTE: Two of the storage writes (`Self::bonded`, `Self::payee`) are _never_ cleaned
             * unless the `origin` falls below _existential deposit_ and gets removed as dust.
             * ------------------
             * Weight: O(1)
             * DB Weight:
             * - Read: Bonded, Ledger, [Origin Account], Current Era, History Depth, Locks
             * - Write: Bonded, Payee, [Origin Account], Locks, Ledger
             * # </weight>
             **/
            bond: AugmentedSubmittable<(controller: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, value: Compact<BalanceOf> | AnyNumber | Uint8Array, payee: RewardDestination | {
                Staked: any;
            } | {
                Stash: any;
            } | {
                Controller: any;
            } | {
                Account: any;
            } | {
                None: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Compact<BalanceOf>, RewardDestination]>;
            /**
             * Add some extra amount that have appeared in the stash `free_balance` into the balance up
             * for staking.
             *
             * Use this if there are additional funds in your stash account that you wish to bond.
             * Unlike [`bond`] or [`unbond`] this function does not impose any limitation on the amount
             * that can be added.
             *
             * The dispatch origin for this call must be _Signed_ by the stash, not the controller and
             * it can be only called when [`EraElectionStatus`] is `Closed`.
             *
             * Emits `Bonded`.
             *
             * # <weight>
             * - Independent of the arguments. Insignificant complexity.
             * - O(1).
             * - One DB entry.
             * ------------
             * DB Weight:
             * - Read: Era Election Status, Bonded, Ledger, [Origin Account], Locks
             * - Write: [Origin Account], Locks, Ledger
             * # </weight>
             **/
            bondExtra: AugmentedSubmittable<(maxAdditional: Compact<BalanceOf> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BalanceOf>]>;
            /**
             * Cancel enactment of a deferred slash.
             *
             * Can be called by the `T::SlashCancelOrigin`.
             *
             * Parameters: era and indices of the slashes for that era to kill.
             *
             * # <weight>
             * Complexity: O(U + S)
             * with U unapplied slashes weighted with U=1000
             * and S is the number of slash indices to be canceled.
             * - Read: Unapplied Slashes
             * - Write: Unapplied Slashes
             * # </weight>
             **/
            cancelDeferredSlash: AugmentedSubmittable<(era: EraIndex | AnyNumber | Uint8Array, slashIndices: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [EraIndex, Vec<u32>]>;
            /**
             * Declare no desire to either validate or nominate.
             *
             * Effects will be felt at the beginning of the next era.
             *
             * The dispatch origin for this call must be _Signed_ by the controller, not the stash.
             * And, it can be only called when [`EraElectionStatus`] is `Closed`.
             *
             * # <weight>
             * - Independent of the arguments. Insignificant complexity.
             * - Contains one read.
             * - Writes are limited to the `origin` account key.
             * --------
             * Weight: O(1)
             * DB Weight:
             * - Read: EraElectionStatus, Ledger
             * - Write: Validators, Nominators
             * # </weight>
             **/
            chill: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Force there to be a new era at the end of the next session. After this, it will be
             * reset to normal (non-forced) behaviour.
             *
             * The dispatch origin must be Root.
             *
             * # <weight>
             * - No arguments.
             * - Weight: O(1)
             * - Write ForceEra
             * # </weight>
             **/
            forceNewEra: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Force there to be a new era at the end of sessions indefinitely.
             *
             * The dispatch origin must be Root.
             *
             * # <weight>
             * - Weight: O(1)
             * - Write: ForceEra
             * # </weight>
             **/
            forceNewEraAlways: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Force there to be no new eras indefinitely.
             *
             * The dispatch origin must be Root.
             *
             * # <weight>
             * - No arguments.
             * - Weight: O(1)
             * - Write: ForceEra
             * # </weight>
             **/
            forceNoEras: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Force a current staker to become completely unstaked, immediately.
             *
             * The dispatch origin must be Root.
             *
             * # <weight>
             * O(S) where S is the number of slashing spans to be removed
             * Reads: Bonded, Slashing Spans, Account, Locks
             * Writes: Bonded, Slashing Spans (if S > 0), Ledger, Payee, Validators, Nominators, Account, Locks
             * Writes Each: SpanSlash * S
             * # </weight>
             **/
            forceUnstake: AugmentedSubmittable<(stash: AccountId | string | Uint8Array, numSlashingSpans: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, u32]>;
            /**
             * Increments the ideal number of validators.
             *
             * The dispatch origin must be Root.
             *
             * # <weight>
             * Same as [`set_validator_count`].
             * # </weight>
             **/
            increaseValidatorCount: AugmentedSubmittable<(additional: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
            /**
             * Remove the given nominations from the calling validator.
             *
             * Effects will be felt at the beginning of the next era.
             *
             * The dispatch origin for this call must be _Signed_ by the controller, not the stash.
             * And, it can be only called when [`EraElectionStatus`] is `Closed`. The controller
             * account should represent a validator.
             *
             * - `who`: A list of nominator stash accounts who are nominating this validator which
             * should no longer be nominating this validator.
             *
             * Note: Making this call only makes sense if you first set the validator preferences to
             * block any further nominations.
             **/
            kick: AugmentedSubmittable<(who: Vec<LookupSource> | (LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<LookupSource>]>;
            /**
             * Declare the desire to nominate `targets` for the origin controller.
             *
             * Effects will be felt at the beginning of the next era. This can only be called when
             * [`EraElectionStatus`] is `Closed`.
             *
             * The dispatch origin for this call must be _Signed_ by the controller, not the stash.
             * And, it can be only called when [`EraElectionStatus`] is `Closed`.
             *
             * # <weight>
             * - The transaction's complexity is proportional to the size of `targets` (N)
             * which is capped at CompactAssignments::LIMIT (MAX_NOMINATIONS).
             * - Both the reads and writes follow a similar pattern.
             * ---------
             * Weight: O(N)
             * where N is the number of targets
             * DB Weight:
             * - Reads: Era Election Status, Ledger, Current Era
             * - Writes: Validators, Nominators
             * # </weight>
             **/
            nominate: AugmentedSubmittable<(targets: Vec<LookupSource> | (LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<LookupSource>]>;
            /**
             * Pay out all the stakers behind a single validator for a single era.
             *
             * - `validator_stash` is the stash account of the validator. Their nominators, up to
             * `T::MaxNominatorRewardedPerValidator`, will also receive their rewards.
             * - `era` may be any era between `[current_era - history_depth; current_era]`.
             *
             * The origin of this call must be _Signed_. Any account can call this function, even if
             * it is not one of the stakers.
             *
             * This can only be called when [`EraElectionStatus`] is `Closed`.
             *
             * # <weight>
             * - Time complexity: at most O(MaxNominatorRewardedPerValidator).
             * - Contains a limited number of reads and writes.
             * -----------
             * N is the Number of payouts for the validator (including the validator)
             * Weight:
             * - Reward Destination Staked: O(N)
             * - Reward Destination Controller (Creating): O(N)
             * DB Weight:
             * - Read: EraElectionStatus, CurrentEra, HistoryDepth, ErasValidatorReward,
             * ErasStakersClipped, ErasRewardPoints, ErasValidatorPrefs (8 items)
             * - Read Each: Bonded, Ledger, Payee, Locks, System Account (5 items)
             * - Write Each: System Account, Locks, Ledger (3 items)
             *
             * NOTE: weights are assuming that payouts are made to alive stash account (Staked).
             * Paying even a dead controller is cheaper weight-wise. We don't do any refunds here.
             * # </weight>
             **/
            payoutStakers: AugmentedSubmittable<(validatorStash: AccountId | string | Uint8Array, era: EraIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, EraIndex]>;
            /**
             * Remove all data structure concerning a staker/stash once its balance is at the minimum.
             * This is essentially equivalent to `withdraw_unbonded` except it can be called by anyone
             * and the target `stash` must have no funds left beyond the ED.
             *
             * This can be called from any origin.
             *
             * - `stash`: The stash account to reap. Its balance must be zero.
             *
             * # <weight>
             * Complexity: O(S) where S is the number of slashing spans on the account.
             * DB Weight:
             * - Reads: Stash Account, Bonded, Slashing Spans, Locks
             * - Writes: Bonded, Slashing Spans (if S > 0), Ledger, Payee, Validators, Nominators, Stash Account, Locks
             * - Writes Each: SpanSlash * S
             * # </weight>
             **/
            reapStash: AugmentedSubmittable<(stash: AccountId | string | Uint8Array, numSlashingSpans: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, u32]>;
            /**
             * Rebond a portion of the stash scheduled to be unlocked.
             *
             * The dispatch origin must be signed by the controller, and it can be only called when
             * [`EraElectionStatus`] is `Closed`.
             *
             * # <weight>
             * - Time complexity: O(L), where L is unlocking chunks
             * - Bounded by `MAX_UNLOCKING_CHUNKS`.
             * - Storage changes: Can't increase storage, only decrease it.
             * ---------------
             * - DB Weight:
             * - Reads: EraElectionStatus, Ledger, Locks, [Origin Account]
             * - Writes: [Origin Account], Locks, Ledger
             * # </weight>
             **/
            rebond: AugmentedSubmittable<(value: Compact<BalanceOf> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BalanceOf>]>;
            /**
             * Scale up the ideal number of validators by a factor.
             *
             * The dispatch origin must be Root.
             *
             * # <weight>
             * Same as [`set_validator_count`].
             * # </weight>
             **/
            scaleValidatorCount: AugmentedSubmittable<(factor: Percent | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Percent]>;
            /**
             * (Re-)set the controller of a stash.
             *
             * Effects will be felt at the beginning of the next era.
             *
             * The dispatch origin for this call must be _Signed_ by the stash, not the controller.
             *
             * # <weight>
             * - Independent of the arguments. Insignificant complexity.
             * - Contains a limited number of reads.
             * - Writes are limited to the `origin` account key.
             * ----------
             * Weight: O(1)
             * DB Weight:
             * - Read: Bonded, Ledger New Controller, Ledger Old Controller
             * - Write: Bonded, Ledger New Controller, Ledger Old Controller
             * # </weight>
             **/
            setController: AugmentedSubmittable<(controller: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource]>;
            /**
             * Set `HistoryDepth` value. This function will delete any history information
             * when `HistoryDepth` is reduced.
             *
             * Parameters:
             * - `new_history_depth`: The new history depth you would like to set.
             * - `era_items_deleted`: The number of items that will be deleted by this dispatch.
             * This should report all the storage items that will be deleted by clearing old
             * era history. Needed to report an accurate weight for the dispatch. Trusted by
             * `Root` to report an accurate number.
             *
             * Origin must be root.
             *
             * # <weight>
             * - E: Number of history depths removed, i.e. 10 -> 7 = 3
             * - Weight: O(E)
             * - DB Weight:
             * - Reads: Current Era, History Depth
             * - Writes: History Depth
             * - Clear Prefix Each: Era Stakers, EraStakersClipped, ErasValidatorPrefs
             * - Writes Each: ErasValidatorReward, ErasRewardPoints, ErasTotalStake, ErasStartSessionIndex
             * # </weight>
             **/
            setHistoryDepth: AugmentedSubmittable<(newHistoryDepth: Compact<EraIndex> | AnyNumber | Uint8Array, eraItemsDeleted: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<EraIndex>, Compact<u32>]>;
            /**
             * Set the validators who cannot be slashed (if any).
             *
             * The dispatch origin must be Root.
             *
             * # <weight>
             * - O(V)
             * - Write: Invulnerables
             * # </weight>
             **/
            setInvulnerables: AugmentedSubmittable<(invulnerables: Vec<AccountId> | (AccountId | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId>]>;
            /**
             * (Re-)set the payment target for a controller.
             *
             * Effects will be felt at the beginning of the next era.
             *
             * The dispatch origin for this call must be _Signed_ by the controller, not the stash.
             *
             * # <weight>
             * - Independent of the arguments. Insignificant complexity.
             * - Contains a limited number of reads.
             * - Writes are limited to the `origin` account key.
             * ---------
             * - Weight: O(1)
             * - DB Weight:
             * - Read: Ledger
             * - Write: Payee
             * # </weight>
             **/
            setPayee: AugmentedSubmittable<(payee: RewardDestination | {
                Staked: any;
            } | {
                Stash: any;
            } | {
                Controller: any;
            } | {
                Account: any;
            } | {
                None: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [RewardDestination]>;
            /**
             * Sets the ideal number of validators.
             *
             * The dispatch origin must be Root.
             *
             * # <weight>
             * Weight: O(1)
             * Write: Validator Count
             * # </weight>
             **/
            setValidatorCount: AugmentedSubmittable<(updated: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
            /**
             * Schedule a portion of the stash to be unlocked ready for transfer out after the bond
             * period ends. If this leaves an amount actively bonded less than
             * T::Currency::minimum_balance(), then it is increased to the full amount.
             *
             * Once the unlock period is done, you can call `withdraw_unbonded` to actually move
             * the funds out of management ready for transfer.
             *
             * No more than a limited number of unlocking chunks (see `MAX_UNLOCKING_CHUNKS`)
             * can co-exists at the same time. In that case, [`Call::withdraw_unbonded`] need
             * to be called first to remove some of the chunks (if possible).
             *
             * The dispatch origin for this call must be _Signed_ by the controller, not the stash.
             * And, it can be only called when [`EraElectionStatus`] is `Closed`.
             *
             * Emits `Unbonded`.
             *
             * See also [`Call::withdraw_unbonded`].
             *
             * # <weight>
             * - Independent of the arguments. Limited but potentially exploitable complexity.
             * - Contains a limited number of reads.
             * - Each call (requires the remainder of the bonded balance to be above `minimum_balance`)
             * will cause a new entry to be inserted into a vector (`Ledger.unlocking`) kept in storage.
             * The only way to clean the aforementioned storage item is also user-controlled via
             * `withdraw_unbonded`.
             * - One DB entry.
             * ----------
             * Weight: O(1)
             * DB Weight:
             * - Read: EraElectionStatus, Ledger, CurrentEra, Locks, BalanceOf Stash,
             * - Write: Locks, Ledger, BalanceOf Stash,
             * </weight>
             **/
            unbond: AugmentedSubmittable<(value: Compact<BalanceOf> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BalanceOf>]>;
            /**
             * Declare the desire to validate for the origin controller.
             *
             * Effects will be felt at the beginning of the next era.
             *
             * The dispatch origin for this call must be _Signed_ by the controller, not the stash.
             * And, it can be only called when [`EraElectionStatus`] is `Closed`.
             *
             * # <weight>
             * - Independent of the arguments. Insignificant complexity.
             * - Contains a limited number of reads.
             * - Writes are limited to the `origin` account key.
             * -----------
             * Weight: O(1)
             * DB Weight:
             * - Read: Era Election Status, Ledger
             * - Write: Nominators, Validators
             * # </weight>
             **/
            validate: AugmentedSubmittable<(prefs: ValidatorPrefs | {
                commission?: any;
                blocked?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [ValidatorPrefs]>;
            /**
             * Remove any unlocked chunks from the `unlocking` queue from our management.
             *
             * This essentially frees up that balance to be used by the stash account to do
             * whatever it wants.
             *
             * The dispatch origin for this call must be _Signed_ by the controller, not the stash.
             * And, it can be only called when [`EraElectionStatus`] is `Closed`.
             *
             * Emits `Withdrawn`.
             *
             * See also [`Call::unbond`].
             *
             * # <weight>
             * - Could be dependent on the `origin` argument and how much `unlocking` chunks exist.
             * It implies `consolidate_unlocked` which loops over `Ledger.unlocking`, which is
             * indirectly user-controlled. See [`unbond`] for more detail.
             * - Contains a limited number of reads, yet the size of which could be large based on `ledger`.
             * - Writes are limited to the `origin` account key.
             * ---------------
             * Complexity O(S) where S is the number of slashing spans to remove
             * Update:
             * - Reads: EraElectionStatus, Ledger, Current Era, Locks, [Origin Account]
             * - Writes: [Origin Account], Locks, Ledger
             * Kill:
             * - Reads: EraElectionStatus, Ledger, Current Era, Bonded, Slashing Spans, [Origin
             * Account], Locks, BalanceOf stash
             * - Writes: Bonded, Slashing Spans (if S > 0), Ledger, Payee, Validators, Nominators,
             * [Origin Account], Locks, BalanceOf stash.
             * - Writes Each: SpanSlash * S
             * NOTE: Weight annotation is the kill scenario, we refund otherwise.
             * # </weight>
             **/
            withdrawUnbonded: AugmentedSubmittable<(numSlashingSpans: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        sudo: {
            /**
             * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo key.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * # <weight>
             * - O(1).
             * - Limited storage reads.
             * - One DB change.
             * # </weight>
             **/
            setKey: AugmentedSubmittable<(updated: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource]>;
            /**
             * Authenticates the sudo key and dispatches a function call with `Root` origin.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * # <weight>
             * - O(1).
             * - Limited storage reads.
             * - One DB write (event).
             * - Weight of derivative `call` execution + 10,000.
             * # </weight>
             **/
            sudo: AugmentedSubmittable<(call: Call | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;
            /**
             * Authenticates the sudo key and dispatches a function call with `Signed` origin from
             * a given account.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * # <weight>
             * - O(1).
             * - Limited storage reads.
             * - One DB write (event).
             * - Weight of derivative `call` execution + 10,000.
             * # </weight>
             **/
            sudoAs: AugmentedSubmittable<(who: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, call: Call | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Call]>;
            /**
             * Authenticates the sudo key and dispatches a function call with `Root` origin.
             * This function does not check the weight of the call, and instead allows the
             * Sudo user to specify the weight of the call.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * # <weight>
             * - O(1).
             * - The weight of this call is defined by the caller.
             * # </weight>
             **/
            sudoUncheckedWeight: AugmentedSubmittable<(call: Call | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array, weight: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, Weight]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        system: {
            /**
             * A dispatch that will fill the block weight up to the given ratio.
             **/
            fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;
            /**
             * Kill all storage items with a key that starts with the given prefix.
             *
             * **NOTE:** We rely on the Root origin to provide us the number of subkeys under
             * the prefix we are removing to accurately calculate the weight of this function.
             *
             * # <weight>
             * - `O(P)` where `P` amount of keys with prefix `prefix`
             * - `P` storage deletions.
             * - Base Weight: 0.834 * P µs
             * - Writes: Number of subkeys + 1
             * # </weight>
             **/
            killPrefix: AugmentedSubmittable<(prefix: Key | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Key, u32]>;
            /**
             * Kill some items from storage.
             *
             * # <weight>
             * - `O(IK)` where `I` length of `keys` and `K` length of one key
             * - `I` storage deletions.
             * - Base Weight: .378 * i µs
             * - Writes: Number of items
             * # </weight>
             **/
            killStorage: AugmentedSubmittable<(keys: Vec<Key> | (Key | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Key>]>;
            /**
             * Make some on-chain remark.
             *
             * # <weight>
             * - `O(1)`
             * # </weight>
             **/
            remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Make some on-chain remark and emit event.
             *
             * # <weight>
             * - `O(b)` where b is the length of the remark.
             * - 1 event.
             * # </weight>
             **/
            remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Set the new changes trie configuration.
             *
             * # <weight>
             * - `O(1)`
             * - 1 storage write or delete (codec `O(1)`).
             * - 1 call to `deposit_log`: Uses `append` API, so O(1)
             * - Base Weight: 7.218 µs
             * - DB Weight:
             * - Writes: Changes Trie, System Digest
             * # </weight>
             **/
            setChangesTrieConfig: AugmentedSubmittable<(changesTrieConfig: Option<ChangesTrieConfiguration> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<ChangesTrieConfiguration>]>;
            /**
             * Set the new runtime code.
             *
             * # <weight>
             * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`
             * - 1 storage write (codec `O(C)`).
             * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is expensive).
             * - 1 event.
             * The weight of this function is dependent on the runtime, but generally this is very expensive.
             * We will treat this as a full block.
             * # </weight>
             **/
            setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Set the new runtime code without doing any checks of the given `code`.
             *
             * # <weight>
             * - `O(C)` where `C` length of `code`
             * - 1 storage write (codec `O(C)`).
             * - 1 event.
             * The weight of this function is dependent on the runtime. We will treat this as a full block.
             * # </weight>
             **/
            setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Set the number of pages in the WebAssembly environment's heap.
             *
             * # <weight>
             * - `O(1)`
             * - 1 storage write.
             * - Base Weight: 1.405 µs
             * - 1 write to HEAP_PAGES
             * # </weight>
             **/
            setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
            /**
             * Set some items of storage.
             *
             * # <weight>
             * - `O(I)` where `I` length of `items`
             * - `I` storage writes (`O(1)`).
             * - Base Weight: 0.568 * i µs
             * - Writes: Number of items
             * # </weight>
             **/
            setStorage: AugmentedSubmittable<(items: Vec<KeyValue> | (KeyValue)[]) => SubmittableExtrinsic<ApiType>, [Vec<KeyValue>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        timestamp: {
            /**
             * Set the current time.
             *
             * This call should be invoked exactly once per block. It will panic at the finalization
             * phase, if this call hasn't been invoked by that time.
             *
             * The timestamp should be greater than the previous one by the amount specified by
             * `MinimumPeriod`.
             *
             * The dispatch origin for this call must be `Inherent`.
             *
             * # <weight>
             * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)
             * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in `on_finalize`)
             * - 1 event handler `on_timestamp_set`. Must be `O(1)`.
             * # </weight>
             **/
            set: AugmentedSubmittable<(now: Compact<Moment> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<Moment>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        tips: {
            /**
             * Close and payout a tip.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * The tip identified by `hash` must have finished its countdown period.
             *
             * - `hash`: The identity of the open tip for which a tip value is declared. This is formed
             * as the hash of the tuple of the original tip `reason` and the beneficiary account ID.
             *
             * # <weight>
             * - Complexity: `O(T)` where `T` is the number of tippers.
             * decoding `Tipper` vec of length `T`.
             * `T` is charged as upper bound given by `ContainsLengthBound`.
             * The actual cost depends on the implementation of `T::Tippers`.
             * - DbReads: `Tips`, `Tippers`, `tip finder`
             * - DbWrites: `Reasons`, `Tips`, `Tippers`, `tip finder`
             * # </weight>
             **/
            closeTip: AugmentedSubmittable<(hash: Hash | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash]>;
            /**
             * Report something `reason` that deserves a tip and claim any eventual the finder's fee.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * Payment: `TipReportDepositBase` will be reserved from the origin account, as well as
             * `DataDepositPerByte` for each byte in `reason`.
             *
             * - `reason`: The reason for, or the thing that deserves, the tip; generally this will be
             * a UTF-8-encoded URL.
             * - `who`: The account which should be credited for the tip.
             *
             * Emits `NewTip` if successful.
             *
             * # <weight>
             * - Complexity: `O(R)` where `R` length of `reason`.
             * - encoding and hashing of 'reason'
             * - DbReads: `Reasons`, `Tips`
             * - DbWrites: `Reasons`, `Tips`
             * # </weight>
             **/
            reportAwesome: AugmentedSubmittable<(reason: Bytes | string | Uint8Array, who: AccountId | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, AccountId]>;
            /**
             * Retract a prior tip-report from `report_awesome`, and cancel the process of tipping.
             *
             * If successful, the original deposit will be unreserved.
             *
             * The dispatch origin for this call must be _Signed_ and the tip identified by `hash`
             * must have been reported by the signing account through `report_awesome` (and not
             * through `tip_new`).
             *
             * - `hash`: The identity of the open tip for which a tip value is declared. This is formed
             * as the hash of the tuple of the original tip `reason` and the beneficiary account ID.
             *
             * Emits `TipRetracted` if successful.
             *
             * # <weight>
             * - Complexity: `O(1)`
             * - Depends on the length of `T::Hash` which is fixed.
             * - DbReads: `Tips`, `origin account`
             * - DbWrites: `Reasons`, `Tips`, `origin account`
             * # </weight>
             **/
            retractTip: AugmentedSubmittable<(hash: Hash | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash]>;
            /**
             * Remove and slash an already-open tip.
             *
             * May only be called from `T::RejectOrigin`.
             *
             * As a result, the finder is slashed and the deposits are lost.
             *
             * Emits `TipSlashed` if successful.
             *
             * # <weight>
             * `T` is charged as upper bound given by `ContainsLengthBound`.
             * The actual cost depends on the implementation of `T::Tippers`.
             * # </weight>
             **/
            slashTip: AugmentedSubmittable<(hash: Hash | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash]>;
            /**
             * Declare a tip value for an already-open tip.
             *
             * The dispatch origin for this call must be _Signed_ and the signing account must be a
             * member of the `Tippers` set.
             *
             * - `hash`: The identity of the open tip for which a tip value is declared. This is formed
             * as the hash of the tuple of the hash of the original tip `reason` and the beneficiary
             * account ID.
             * - `tip_value`: The amount of tip that the sender would like to give. The median tip
             * value of active tippers will be given to the `who`.
             *
             * Emits `TipClosing` if the threshold of tippers has been reached and the countdown period
             * has started.
             *
             * # <weight>
             * - Complexity: `O(T)` where `T` is the number of tippers.
             * decoding `Tipper` vec of length `T`, insert tip and check closing,
             * `T` is charged as upper bound given by `ContainsLengthBound`.
             * The actual cost depends on the implementation of `T::Tippers`.
             *
             * Actually weight could be lower as it depends on how many tips are in `OpenTip` but it
             * is weighted as if almost full i.e of length `T-1`.
             * - DbReads: `Tippers`, `Tips`
             * - DbWrites: `Tips`
             * # </weight>
             **/
            tip: AugmentedSubmittable<(hash: Hash | string | Uint8Array, tipValue: Compact<BalanceOf> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash, Compact<BalanceOf>]>;
            /**
             * Give a tip for something new; no finder's fee will be taken.
             *
             * The dispatch origin for this call must be _Signed_ and the signing account must be a
             * member of the `Tippers` set.
             *
             * - `reason`: The reason for, or the thing that deserves, the tip; generally this will be
             * a UTF-8-encoded URL.
             * - `who`: The account which should be credited for the tip.
             * - `tip_value`: The amount of tip that the sender would like to give. The median tip
             * value of active tippers will be given to the `who`.
             *
             * Emits `NewTip` if successful.
             *
             * # <weight>
             * - Complexity: `O(R + T)` where `R` length of `reason`, `T` is the number of tippers.
             * - `O(T)`: decoding `Tipper` vec of length `T`
             * `T` is charged as upper bound given by `ContainsLengthBound`.
             * The actual cost depends on the implementation of `T::Tippers`.
             * - `O(R)`: hashing and encoding of reason of length `R`
             * - DbReads: `Tippers`, `Reasons`
             * - DbWrites: `Reasons`, `Tips`
             * # </weight>
             **/
            tipNew: AugmentedSubmittable<(reason: Bytes | string | Uint8Array, who: AccountId | string | Uint8Array, tipValue: Compact<BalanceOf> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, AccountId, Compact<BalanceOf>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        treasury: {
            /**
             * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary
             * and the original deposit will be returned.
             *
             * May only be called from `T::ApproveOrigin`.
             *
             * # <weight>
             * - Complexity: O(1).
             * - DbReads: `Proposals`, `Approvals`
             * - DbWrite: `Approvals`
             * # </weight>
             **/
            approveProposal: AugmentedSubmittable<(proposalId: Compact<ProposalIndex> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<ProposalIndex>]>;
            /**
             * Put forward a suggestion for spending. A deposit proportional to the value
             * is reserved and slashed if the proposal is rejected. It is returned once the
             * proposal is awarded.
             *
             * # <weight>
             * - Complexity: O(1)
             * - DbReads: `ProposalCount`, `origin account`
             * - DbWrites: `ProposalCount`, `Proposals`, `origin account`
             * # </weight>
             **/
            proposeSpend: AugmentedSubmittable<(value: Compact<BalanceOf> | AnyNumber | Uint8Array, beneficiary: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BalanceOf>, LookupSource]>;
            /**
             * Reject a proposed spend. The original deposit will be slashed.
             *
             * May only be called from `T::RejectOrigin`.
             *
             * # <weight>
             * - Complexity: O(1)
             * - DbReads: `Proposals`, `rejected proposer account`
             * - DbWrites: `Proposals`, `rejected proposer account`
             * # </weight>
             **/
            rejectProposal: AugmentedSubmittable<(proposalId: Compact<ProposalIndex> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<ProposalIndex>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        treasuryReward: {
            /**
             * Sets the fixed treasury payout per minting interval.
             **/
            setCurrentPayout: AugmentedSubmittable<(payout: BalanceOf | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [BalanceOf]>;
            /**
             * Sets the treasury minting interval.
             **/
            setMintingInterval: AugmentedSubmittable<(interval: BlockNumber | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [BlockNumber]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        utility: {
            /**
             * Send a call through an indexed pseudonym of the sender.
             *
             * Filter from origin are passed along. The call will be dispatched with an origin which
             * use the same filter as the origin of this call.
             *
             * NOTE: If you need to ensure that any account-based filtering is not honored (i.e.
             * because you expect `proxy` to have been used prior in the call stack and you do not want
             * the call restrictions to apply to any sub-accounts), then use `as_multi_threshold_1`
             * in the Multisig pallet instead.
             *
             * NOTE: Prior to version *12, this was called `as_limited_sub`.
             *
             * The dispatch origin for this call must be _Signed_.
             **/
            asDerivative: AugmentedSubmittable<(index: u16 | AnyNumber | Uint8Array, call: Call | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Call]>;
            /**
             * Send a batch of dispatch calls.
             *
             * May be called from any origin.
             *
             * - `calls`: The calls to be dispatched from the same origin.
             *
             * If origin is root then call are dispatch without checking origin filter. (This includes
             * bypassing `frame_system::Config::BaseCallFilter`).
             *
             * # <weight>
             * - Complexity: O(C) where C is the number of calls to be batched.
             * # </weight>
             *
             * This will return `Ok` in all circumstances. To determine the success of the batch, an
             * event is deposited. If a call failed and the batch was interrupted, then the
             * `BatchInterrupted` event is deposited, along with the number of successful calls made
             * and the error of the failed call. If all were successful, then the `BatchCompleted`
             * event is deposited.
             **/
            batch: AugmentedSubmittable<(calls: Vec<Call> | (Call | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;
            /**
             * Send a batch of dispatch calls and atomically execute them.
             * The whole transaction will rollback and fail if any of the calls failed.
             *
             * May be called from any origin.
             *
             * - `calls`: The calls to be dispatched from the same origin.
             *
             * If origin is root then call are dispatch without checking origin filter. (This includes
             * bypassing `frame_system::Config::BaseCallFilter`).
             *
             * # <weight>
             * - Complexity: O(C) where C is the number of calls to be batched.
             * # </weight>
             **/
            batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | {
                callIndex?: any;
                args?: any;
            } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        vesting: {
            /**
             * Force a vested transfer.
             *
             * The dispatch origin for this call must be _Root_.
             *
             * - `source`: The account whose funds should be transferred.
             * - `target`: The account that should be transferred the vested funds.
             * - `amount`: The amount of funds to transfer and will be vested.
             * - `schedule`: The vesting schedule attached to the transfer.
             *
             * Emits `VestingCreated`.
             *
             * # <weight>
             * - `O(1)`.
             * - DbWeight: 4 Reads, 4 Writes
             * - Reads: Vesting Storage, Balances Locks, Target Account, Source Account
             * - Writes: Vesting Storage, Balances Locks, Target Account, Source Account
             * # </weight>
             **/
            forceVestedTransfer: AugmentedSubmittable<(source: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, target: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, schedule: VestingInfo | {
                locked?: any;
                perBlock?: any;
                startingBlock?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, LookupSource, VestingInfo]>;
            /**
             * Unlock any vested funds of the sender account.
             *
             * The dispatch origin for this call must be _Signed_ and the sender must have funds still
             * locked under this pallet.
             *
             * Emits either `VestingCompleted` or `VestingUpdated`.
             *
             * # <weight>
             * - `O(1)`.
             * - DbWeight: 2 Reads, 2 Writes
             * - Reads: Vesting Storage, Balances Locks, [Sender Account]
             * - Writes: Vesting Storage, Balances Locks, [Sender Account]
             * # </weight>
             **/
            vest: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Unlock any vested funds of a `target` account.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * - `target`: The account whose vested funds should be unlocked. Must have funds still
             * locked under this pallet.
             *
             * Emits either `VestingCompleted` or `VestingUpdated`.
             *
             * # <weight>
             * - `O(1)`.
             * - DbWeight: 3 Reads, 3 Writes
             * - Reads: Vesting Storage, Balances Locks, Target Account
             * - Writes: Vesting Storage, Balances Locks, Target Account
             * # </weight>
             **/
            vestOther: AugmentedSubmittable<(target: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource]>;
            /**
             * Create a vested transfer.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * - `target`: The account that should be transferred the vested funds.
             * - `amount`: The amount of funds to transfer and will be vested.
             * - `schedule`: The vesting schedule attached to the transfer.
             *
             * Emits `VestingCreated`.
             *
             * # <weight>
             * - `O(1)`.
             * - DbWeight: 3 Reads, 3 Writes
             * - Reads: Vesting Storage, Balances Locks, Target Account, [Sender Account]
             * - Writes: Vesting Storage, Balances Locks, Target Account, [Sender Account]
             * # </weight>
             **/
            vestedTransfer: AugmentedSubmittable<(target: LookupSource | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, schedule: VestingInfo | {
                locked?: any;
                perBlock?: any;
                startingBlock?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, VestingInfo]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
    }
    interface SubmittableExtrinsics<ApiType extends ApiTypes> extends AugmentedSubmittables<ApiType> {
        (extrinsic: Call | Extrinsic | Uint8Array | string): SubmittableExtrinsic<ApiType>;
        [key: string]: SubmittableModuleExtrinsics<ApiType>;
    }
}