import '@polkadot/api-base/types/submittable';
import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types';
import type { Bytes, Compact, Null, Option, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';
import type { AccountId32, Call, H256, MultiAddress } from '@polkadot/types/interfaces/runtime';
import type { CommonPrimitivesHandlesClaimHandlePayload, CommonPrimitivesMsaProviderRegistryEntry, CommonPrimitivesSchemaModelType, CommonPrimitivesSchemaPayloadLocation, CommonPrimitivesSchemaSchemaSetting, CommonRuntimeProxyProxyType, CumulusPrimitivesParachainInherentParachainInherentData, FrameSupportPreimagesBounded, FrequencyRuntimeOriginCaller, FrequencyRuntimeSessionKeys, PalletBalancesAdjustmentDirection, PalletDemocracyConviction, PalletDemocracyMetadataOwner, PalletDemocracyVoteAccountVote, PalletMsaAddKeyData, PalletMsaAddProvider, PalletMsaAuthorizedKeyData, PalletMsaOffchainStorageOffchainReplayEvent, PalletMsaRecoveryCommitmentPayload, PalletMultisigTimepoint, PalletPasskeyPasskeyPayload, PalletPasskeyPasskeyPayloadV2, PalletStatefulStorageItemAction, PalletStatefulStorageItemizedSignaturePayloadV2, PalletStatefulStoragePaginatedDeleteSignaturePayloadV2, PalletStatefulStoragePaginatedUpsertSignaturePayloadV2, PalletTimeReleaseReleaseSchedule, SpRuntimeMultiSignature, SpWeightsWeightV2Weight } from '@polkadot/types/lookup';
export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;
export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;
export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;
declare module '@polkadot/api-base/types/submittable' {
    interface AugmentedSubmittables<ApiType extends ApiTypes> {
        balances: {
            /**
             * Burn the specified liquid free balance from the origin account.
             *
             * If the origin's account ends up below the existential deposit as a result
             * of the burn and `keep_alive` is false, the account will be reaped.
             *
             * Unlike sending funds to a _burn_ address, which merely makes the funds inaccessible,
             * this `burn` operation will reduce total issuance by the amount _burned_.
             **/
            burn: AugmentedSubmittable<(value: Compact<u128> | AnyNumber | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>, bool]>;
            /**
             * Adjust the total issuance in a saturating way.
             *
             * Can only be called by root and always needs a positive `delta`.
             *
             * # Example
             **/
            forceAdjustTotalIssuance: AugmentedSubmittable<(direction: PalletBalancesAdjustmentDirection | 'Increase' | 'Decrease' | number | Uint8Array, delta: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletBalancesAdjustmentDirection, Compact<u128>]>;
            /**
             * Set the regular balance of a given account.
             *
             * The dispatch origin for this call is `root`.
             **/
            forceSetBalance: AugmentedSubmittable<(who: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;
            /**
             * Exactly as `transfer_allow_death`, except the origin must be root and the source account
             * may be specified.
             **/
            forceTransfer: AugmentedSubmittable<(source: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, dest: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, Compact<u128>]>;
            /**
             * Unreserve some balance from a user by force.
             *
             * Can only be called by ROOT.
             **/
            forceUnreserve: AugmentedSubmittable<(who: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;
            /**
             * Transfer the entire transferable balance from the caller account.
             *
             * NOTE: This function only attempts to transfer _transferable_ balances. This means that
             * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be
             * transferred by this function. To ensure that this function results in a killed account,
             * you might need to prepare the account by removing any reference counters, storage
             * deposits, etc...
             *
             * The dispatch origin of this call must be Signed.
             *
             * - `dest`: The recipient of the transfer.
             * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all
             * of the funds the account has, causing the sender account to be killed (false), or
             * transfer everything except at least the existential deposit, which will guarantee to
             * keep the sender account alive (true).
             **/
            transferAll: AugmentedSubmittable<(dest: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;
            /**
             * Transfer some liquid free balance to another account.
             *
             * `transfer_allow_death` will set the `FreeBalance` of the sender and receiver.
             * 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.
             **/
            transferAllowDeath: AugmentedSubmittable<(dest: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;
            /**
             * Same as the [`transfer_allow_death`] call, but with a check that the transfer will not
             * kill the origin account.
             *
             * 99% of the time you want [`transfer_allow_death`] instead.
             *
             * [`transfer_allow_death`]: struct.Pallet.html#method.transfer
             **/
            transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;
            /**
             * Upgrade a specified account.
             *
             * - `origin`: Must be `Signed`.
             * - `who`: The account to be upgraded.
             *
             * This will waive the transaction fee if at least all but 10% of the accounts needed to
             * be upgraded. (We let some not have to be upgraded just in order to allow for the
             * possibility of churn).
             **/
            upgradeAccounts: AugmentedSubmittable<(who: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        capacity: {
            /**
             * Sets the target of the staking capacity to a new target.
             * This adds a chunk to `StakingDetails.stake_change_unlocking chunks`, up to `T::MaxUnlockingChunks`.
             * The staked amount and Capacity generated by `amount` originally targeted to the `from` MSA Id is reassigned to the `to` MSA Id.
             * Does not affect unstaking process or additional stake amounts.
             * Changing a staking target to a Provider when Origin has nothing staked them will retain the staking type.
             * Changing a staking target to a Provider when Origin has any amount staked to them will error if the staking types are not the same.
             * ### Errors
             * - [`Error::MaxUnlockingChunksExceeded`] if `stake_change_unlocking_chunks` == `T::MaxUnlockingChunks`
             * - [`Error::StakerTargetRelationshipNotFound`] if `from` is not a target for Origin's staking account.
             * - [`Error::StakingAmountBelowMinimum`] if `amount` to retarget is below the minimum staking amount.
             * - [`Error::InsufficientStakingBalance`] if `amount` to retarget exceeds what the staker has targeted to `from` MSA Id.
             * - [`Error::InvalidTarget`] if `to` does not belong to a registered Provider.
             * - [`Error::MaxRetargetsExceeded`] if origin has reached the maximimum number of retargets for the current RewardEra.
             **/
            changeStakingTarget: AugmentedSubmittable<(from: u64 | AnyNumber | Uint8Array, to: u64 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64, u128]>;
            /**
             * Claim all outstanding Provider Boost rewards, up to ProviderBoostHistoryLimit Reward Eras
             * in the past.  Accounts should check for unclaimed rewards before calling this extrinsic
             * to avoid needless transaction fees.
             * ### Errors:
             * - NotAProviderBoostAccount:  if Origin has nothing staked for ProviderBoost
             * - NoRewardsEligibleToClaim:  if Origin has no unclaimed rewards to pay out.
             **/
            claimStakingRewards: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Stakes some amount of tokens to the network and generates a comparatively small amount of Capacity
             * for the target, and gives periodic rewards to origin.
             * ### Errors
             *
             * - Error::InvalidTarget if attempting to stake to an invalid target.
             * - Error::StakingAmountBelowMinimum if attempting to stake an amount below the minimum amount.
             * - Error::CannotChangeStakingType if the staking account exists and staking_type is MaximumCapacity
             **/
            providerBoost: AugmentedSubmittable<(target: u64 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u128]>;
            /**
             * Sets the epoch period length (in blocks).
             *
             * # Requires
             * * Root Origin
             *
             * ### Errors
             * - Returns `Error::MaxEpochLengthExceeded` if `length` is greater than T::MaxEpochLength.
             **/
            setEpochLength: AugmentedSubmittable<(length: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * Stakes some amount of tokens to the network and generates Capacity.
             *
             * ### Errors
             *
             * - Returns Error::InvalidTarget if attempting to stake to an invalid target.
             * - Returns Error::StakingAmountBelowMinimum if attempting to stake an amount below the minimum amount.
             * - Returns Error::CannotChangeStakingType if the staking account is a ProviderBoost account
             **/
            stake: AugmentedSubmittable<(target: u64 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u128]>;
            /**
             * Schedules an amount of the stake to be unlocked.
             * ### Errors
             *
             * - Returns `Error::UnstakedAmountIsZero` if `amount` is not greater than zero.
             * - Returns `Error::MaxUnlockingChunksExceeded` if attempting to unlock more times than config::MaxUnlockingChunks.
             * - Returns `Error::AmountToUnstakeExceedsAmountStaked` if `amount` exceeds the amount currently staked.
             * - Returns `Error::InvalidTarget` if `target` is not a valid staking target (not a Provider)
             * - Returns `Error::NotAStakingAccount` if `origin` has nothing staked at all
             * - Returns `Error::StakerTargetRelationshipNotFound` if `origin` has nothing staked to `target`
             **/
            unstake: AugmentedSubmittable<(target: u64 | AnyNumber | Uint8Array, requestedAmount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u128]>;
            /**
             * Removes all thawed UnlockChunks from caller's UnstakeUnlocks and thaws(unfreezes) the sum of the thawed values
             * in the caller's token account.
             *
             * ### Errors
             * - Returns `Error::NoUnstakedTokensAvailable` if the account has no unstaking chunks.
             * - Returns `Error::NoThawedTokenAvailable` if there are unstaking chunks, but none are thawed.
             **/
            withdrawUnstaked: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        collatorSelection: {
            /**
             * Add a new account `who` to the list of `Invulnerables` collators. `who` must have
             * registered session keys. If `who` is a candidate, they will be removed.
             *
             * The origin for this call must be the `UpdateOrigin`.
             **/
            addInvulnerable: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
            /**
             * Deregister `origin` as a collator candidate. Note that the collator can only leave on
             * session change. The `CandidacyBond` will be unreserved immediately.
             *
             * This call will fail if the total number of candidates would drop below
             * `MinEligibleCollators`.
             **/
            leaveIntent: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Register this account as a collator candidate. The account must (a) already have
             * registered session keys and (b) be able to reserve the `CandidacyBond`.
             *
             * This call is not available to `Invulnerable` collators.
             **/
            registerAsCandidate: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Remove an account `who` from the list of `Invulnerables` collators. `Invulnerables` must
             * be sorted.
             *
             * The origin for this call must be the `UpdateOrigin`.
             **/
            removeInvulnerable: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
            /**
             * Set the candidacy bond amount.
             *
             * If the candidacy bond is increased by this call, all current candidates which have a
             * deposit lower than the new bond will be kicked from the list and get their deposits
             * back.
             *
             * The origin for this call must be the `UpdateOrigin`.
             **/
            setCandidacyBond: AugmentedSubmittable<(bond: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
            /**
             * Set the ideal number of non-invulnerable collators. If lowering this number, then the
             * number of running collators could be higher than this figure. Aside from that edge case,
             * there should be no other way to have more candidates than the desired number.
             *
             * The origin for this call must be the `UpdateOrigin`.
             **/
            setDesiredCandidates: AugmentedSubmittable<(max: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * Set the list of invulnerable (fixed) collators. These collators must do some
             * preparation, namely to have registered session keys.
             *
             * The call will remove any accounts that have not registered keys from the set. That is,
             * it is non-atomic; the caller accepts all `AccountId`s passed in `new` _individually_ as
             * acceptable Invulnerables, and is not proposing a _set_ of new Invulnerables.
             *
             * This call does not maintain mutual exclusivity of `Invulnerables` and `Candidates`. It
             * is recommended to use a batch of `add_invulnerable` and `remove_invulnerable` instead. A
             * `batch_all` can also be used to enforce atomicity. If any candidates are included in
             * `new`, they should be removed with `remove_invulnerable_candidate` after execution.
             *
             * Must be called by the `UpdateOrigin`.
             **/
            setInvulnerables: AugmentedSubmittable<(updated: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;
            /**
             * The caller `origin` replaces a candidate `target` in the collator candidate list by
             * reserving `deposit`. The amount `deposit` reserved by the caller must be greater than
             * the existing bond of the target it is trying to replace.
             *
             * This call will fail if the caller is already a collator candidate or invulnerable, the
             * caller does not have registered session keys, the target is not a collator candidate,
             * and/or the `deposit` amount cannot be reserved.
             **/
            takeCandidateSlot: AugmentedSubmittable<(deposit: u128 | AnyNumber | Uint8Array, target: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128, AccountId32]>;
            /**
             * Update the candidacy bond of collator candidate `origin` to a new amount `new_deposit`.
             *
             * Setting a `new_deposit` that is lower than the current deposit while `origin` is
             * occupying a top-`DesiredCandidates` slot is not allowed.
             *
             * This call will fail if `origin` is not a collator candidate, the updated bond is lower
             * than the minimum candidacy bond, and/or the amount cannot be reserved.
             **/
            updateBond: AugmentedSubmittable<(newDeposit: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
            /**
             * 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.
             *
             * ## Complexity
             * - `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)
             **/
            close: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, index: Compact<u32> | AnyNumber | Uint8Array, proposalWeightBound: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, Compact<u32>, SpWeightsWeightV2Weight, 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.
             *
             * ## Complexity
             * O(P) where P is the number of max proposals
             **/
            disapproveProposal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * Dispatch a proposal from a member using the `Member` origin.
             *
             * Origin must be a member of the collective.
             *
             * ## Complexity:
             * - `O(B + M + P)` where:
             * - `B` is `proposal` size in bytes (length-fee-bounded)
             * - `M` members-count (code-bounded)
             * - `P` complexity of dispatching `proposal`
             **/
            execute: AugmentedSubmittable<(proposal: Call | IMethod | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, Compact<u32>]>;
            /**
             * Disapprove the proposal and burn the cost held for storing this proposal.
             *
             * Parameters:
             * - `origin`: must be the `KillOrigin`.
             * - `proposal_hash`: The hash of the proposal that should be killed.
             *
             * Emits `Killed` and `ProposalCostBurned` if any cost was held for a given proposal.
             **/
            kill: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * 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.
             *
             * ## Complexity
             * - `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`)
             **/
            propose: AugmentedSubmittable<(threshold: Compact<u32> | AnyNumber | Uint8Array, proposal: Call | IMethod | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Call, Compact<u32>]>;
            /**
             * Release the cost held for storing a proposal once the given proposal is completed.
             *
             * If there is no associated cost for the given proposal, this call will have no effect.
             *
             * Parameters:
             * - `origin`: must be `Signed` or `Root`.
             * - `proposal_hash`: The hash of the proposal.
             *
             * Emits `ProposalCostReleased` if any cost held for a given proposal.
             **/
            releaseProposalCost: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * 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.
             *
             * The dispatch of this call must be `SetMembersOrigin`.
             *
             * NOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but
             * the weight estimations rely on it to estimate dispatchable weight.
             *
             * # WARNING:
             *
             * The `pallet-collective` can also be managed by logic outside of the pallet through the
             * implementation of the trait [`ChangeMembers`].
             * Any call to `set_members` must be careful that the member set doesn't get out of sync
             * with other logic managing the member set.
             *
             * ## Complexity:
             * - `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)
             **/
            setMembers: AugmentedSubmittable<(newMembers: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], prime: Option<AccountId32> | null | Uint8Array | AccountId32 | string, oldCount: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>, Option<AccountId32>, u32]>;
            /**
             * 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.
             * ## Complexity
             * - `O(M)` where `M` is members-count (code- and governance-bounded)
             **/
            vote: AugmentedSubmittable<(proposal: H256 | string | Uint8Array, index: Compact<u32> | AnyNumber | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, Compact<u32>, 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: H256 | string | Uint8Array, maybeRefIndex: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [H256, Option<u32>]>;
            /**
             * 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<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
            /**
             * 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<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
            /**
             * 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: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, conviction: PalletDemocracyConviction | 'None' | 'Locked1x' | 'Locked2x' | 'Locked3x' | 'Locked4x' | 'Locked5x' | 'Locked6x' | number | Uint8Array, balance: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletDemocracyConviction, u128]>;
            /**
             * 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: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * 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.
             **/
            externalPropose: AugmentedSubmittable<(proposal: FrameSupportPreimagesBounded | {
                Legacy: any;
            } | {
                Inline: any;
            } | {
                Lookup: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [FrameSupportPreimagesBounded]>;
            /**
             * 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<(proposal: FrameSupportPreimagesBounded | {
                Legacy: any;
            } | {
                Inline: any;
            } | {
                Lookup: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [FrameSupportPreimagesBounded]>;
            /**
             * 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<(proposal: FrameSupportPreimagesBounded | {
                Legacy: any;
            } | {
                Inline: any;
            } | {
                Lookup: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [FrameSupportPreimagesBounded]>;
            /**
             * 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
             * Must be always greater than zero.
             * For `FastTrackOrigin` must be equal or greater than `FastTrackVotingPeriod`.
             * - `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: H256 | string | Uint8Array, votingPeriod: u32 | AnyNumber | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, u32, u32]>;
            /**
             * 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`.
             **/
            propose: AugmentedSubmittable<(proposal: FrameSupportPreimagesBounded | {
                Legacy: any;
            } | {
                Inline: any;
            } | {
                Lookup: any;
            } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [FrameSupportPreimagesBounded, Compact<u128>]>;
            /**
             * 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: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u32]>;
            /**
             * 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: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * 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.
             **/
            second: AugmentedSubmittable<(proposal: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
            /**
             * Set or clear a metadata of a proposal or a referendum.
             *
             * Parameters:
             * - `origin`: Must correspond to the `MetadataOwner`.
             * - `ExternalOrigin` for an external proposal with the `SuperMajorityApprove`
             * threshold.
             * - `ExternalDefaultOrigin` for an external proposal with the `SuperMajorityAgainst`
             * threshold.
             * - `ExternalMajorityOrigin` for an external proposal with the `SimpleMajority`
             * threshold.
             * - `Signed` by a creator for a public proposal.
             * - `Signed` to clear a metadata for a finished referendum.
             * - `Root` to set a metadata for an ongoing referendum.
             * - `owner`: an identifier of a metadata owner.
             * - `maybe_hash`: The hash of an on-chain stored preimage. `None` to clear a metadata.
             **/
            setMetadata: AugmentedSubmittable<(owner: PalletDemocracyMetadataOwner | {
                External: any;
            } | {
                Proposal: any;
            } | {
                Referendum: any;
            } | string | Uint8Array, maybeHash: Option<H256> | null | Uint8Array | H256 | string) => SubmittableExtrinsic<ApiType>, [PalletDemocracyMetadataOwner, Option<H256>]>;
            /**
             * 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: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;
            /**
             * 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: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * 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.
             **/
            vote: AugmentedSubmittable<(refIndex: Compact<u32> | AnyNumber | Uint8Array, vote: PalletDemocracyVoteAccountVote | {
                Standard: any;
            } | {
                Split: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, PalletDemocracyVoteAccountVote]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        frequencyTxPayment: {
            /**
             * Dispatch the given call as a sub_type of pay_with_capacity. Calls dispatched in this
             * fashion, if allowed, will pay with Capacity.
             **/
            payWithCapacity: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;
            /**
             * Dispatch the given call as a sub_type of pay_with_capacity_batch_all. Calls dispatched in this
             * fashion, if allowed, will pay with Capacity.
             **/
            payWithCapacityBatchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        handles: {
            /**
             * Changes the handle for a caller's MSA (Message Source Account) based on the provided payload.
             * This function performs several validations before claiming the handle, including checking
             * the size of the base_handle, ensuring the caller has valid MSA keys,
             * verifying the payload signature, and finally calling the internal `do_retire_handle` and `do_claim_handle` functions
             * to retire the current handle and claim the new one.
             *
             * # Arguments
             *
             * * `origin` - The origin of the caller.
             * * `msa_owner_key` - The public key of the MSA owner.
             * * `proof` - The multi-signature proof for the payload.
             * * `payload` - The payload containing the information needed to change an existing handle.
             *
             * # Errors
             *
             * This function may return an error as part of `DispatchResult` if any of the following
             * validations fail:
             *
             * * [`Error::InvalidHandleByteLength`] - The base_handle size exceeds the maximum allowed size.
             * * [`Error::InvalidMessageSourceAccount`] - The caller does not have a valid  `MessageSourceId`.
             * * [`Error::InvalidSignature`] - The payload signature verification fails.
             *
             * # Events
             * * [`Event::HandleRetired`]
             * * [`Event::HandleClaimed`]
             *
             **/
            changeHandle: AugmentedSubmittable<(msaOwnerKey: AccountId32 | string | Uint8Array, proof: SpRuntimeMultiSignature | {
                Ed25519: any;
            } | {
                Sr25519: any;
            } | {
                Ecdsa: any;
            } | string | Uint8Array, payload: CommonPrimitivesHandlesClaimHandlePayload | {
                baseHandle?: any;
                expiration?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, SpRuntimeMultiSignature, CommonPrimitivesHandlesClaimHandlePayload]>;
            /**
             * Claims a handle for a caller's MSA (Message Source Account) based on the provided payload.
             * This function performs several validations before claiming the handle, including checking
             * the size of the base_handle, ensuring the caller have valid MSA keys,
             * verifying the payload signature, and finally calling the internal `do_claim_handle` function
             * to claim the handle.
             *
             * # Arguments
             *
             * * `origin` - The origin of the caller.
             * * `msa_owner_key` - The public key of the MSA owner.
             * * `proof` - The multi-signature proof for the payload.
             * * `payload` - The payload containing the information needed to claim a new handle.
             *
             * # Errors
             *
             * This function may return an error as part of `DispatchResult` if any of the following
             * validations fail:
             *
             * * [`Error::InvalidHandleByteLength`] - The base_handle size exceeds the maximum allowed size.
             * * [`Error::InvalidMessageSourceAccount`] - The caller does not have a valid  `MessageSourceId`.
             * * [`Error::InvalidSignature`] - The payload signature verification fails.
             *
             * # Events
             * * [`Event::HandleClaimed`]
             *
             **/
            claimHandle: AugmentedSubmittable<(msaOwnerKey: AccountId32 | string | Uint8Array, proof: SpRuntimeMultiSignature | {
                Ed25519: any;
            } | {
                Sr25519: any;
            } | {
                Ecdsa: any;
            } | string | Uint8Array, payload: CommonPrimitivesHandlesClaimHandlePayload | {
                baseHandle?: any;
                expiration?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, SpRuntimeMultiSignature, CommonPrimitivesHandlesClaimHandlePayload]>;
            /**
             * Retire a handle for a given `DisplayHandle` owner.
             *
             * # Arguments
             *
             * * `origin` - The origin of the call.
             *
             * # Errors
             *
             * This function can return the following errors:
             *
             * * `InvalidHandleByteLength` - If the length of the `payload.display_handle` exceeds the maximum allowed size.
             * * `InvalidMessageSourceAccount` - If caller of this extrinsic does not have a valid MSA (Message Source Account) ID.
             *
             * # Events
             * * [`Event::HandleRetired`]
             *
             **/
            retireHandle: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        messages: {
            /**
             * Adds a message for a resource hosted on IPFS. The input consists of
             * a Base32-encoded [CID](https://docs.ipfs.tech/concepts/content-addressing/#version-1-v1)
             * as well as a 32-bit content length. The stored payload will contain the
             * CID encoded as binary, as well as the 32-bit message content length.
             * The actual message content will be on IPFS.
             *
             * # Events
             * * [`Event::MessagesInBlock`] - Messages Stored in the block
             *
             * # Errors
             * * [`Error::ExceedsMaxMessagePayloadSizeBytes`] - Payload is too large.
             * * [`Error::InvalidSchemaId`] - Schema not found.
             * * [`Error::InvalidPayloadLocation`] - The schema is not an IPFS payload location.
             * * [`Error::InvalidMessageSourceAccount`] - Origin must be from an MSA.
             * * [`Error::TypeConversionOverflow`] - Failed to add the message to storage as it is very full.
             * * [`Error::UnsupportedCidVersion`] - CID version is not supported (V0).
             * * [`Error::InvalidCid`] - Unable to parse provided CID.
             *
             **/
            addIpfsMessage: AugmentedSubmittable<(schemaId: Compact<u16> | AnyNumber | Uint8Array, cid: Bytes | string | Uint8Array, payloadLength: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u16>, Bytes, Compact<u32>]>;
            /**
             * Add an on-chain message for a given schema id.
             *
             * # Events
             * * [`Event::MessagesInBlock`] - In the next block
             *
             * # Errors
             * * [`Error::ExceedsMaxMessagePayloadSizeBytes`] - Payload is too large.
             * * [`Error::InvalidSchemaId`] - Schema not found.
             * * [`Error::InvalidPayloadLocation`] - The schema is not an IPFS payload location.
             * * [`Error::InvalidMessageSourceAccount`] - Origin must be from an MSA.
             * * [`Error::UnAuthorizedDelegate`] - Trying to add a message without a proper delegation between the origin and the on_behalf_of MSA.
             * * [`Error::TypeConversionOverflow`] - Failed to add the message to storage as it is very full.
             *
             **/
            addOnchainMessage: AugmentedSubmittable<(onBehalfOf: Option<u64> | null | Uint8Array | u64 | AnyNumber, schemaId: Compact<u16> | AnyNumber | Uint8Array, payload: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<u64>, Compact<u16>, Bytes]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        msa: {
            /**
             * Adds a new public key to an existing Message Source Account (MSA). This functionality enables the MSA owner to manage multiple keys
             * for their account or rotate keys for enhanced security.
             *
             * The `origin` parameter represents the account from which the function is called and can be either the MSA owner's account or a delegated provider's account,
             * depending on the intended use.
             *
             * The function requires two signatures: `msa_owner_proof` and `new_key_owner_proof`, which serve as proofs of ownership for the existing MSA
             * and the new public key account, respectively.  This ensures that a new key cannot be added without permission of both the MSA owner and the owner of the new key.
             *
             * The necessary information for the key addition, the new public key and the MSA ID, is contained in the `add_key_payload` parameter of type [AddKeyData].
             * It also contains an expiration block number for both proofs, ensuring they are valid and must be greater than the current block.
             *
             * # Events
             * * [`Event::PublicKeyAdded`]
             *
             * # Errors
             *
             * * [`Error::MsaOwnershipInvalidSignature`] - `key` is not a valid signer of the provided `add_key_payload`.
             * * [`Error::NewKeyOwnershipInvalidSignature`] - `key` is not a valid signer of the provided `add_key_payload`.
             * * [`Error::NoKeyExists`] - the MSA id for the account in `add_key_payload` does not exist.
             * * [`Error::NotMsaOwner`] - Origin's MSA is not the same as 'add_key_payload` MSA. Essentially you can only add a key to your own MSA.
             * * [`Error::ProofHasExpired`] - the current block is less than the `expired` block number set in `AddKeyData`.
             * * [`Error::ProofNotYetValid`] - the `expired` block number set in `AddKeyData` is greater than the current block number plus mortality_block_limit().
             * * [`Error::SignatureAlreadySubmitted`] - signature has already been used.
             *
             **/
            addPublicKeyToMsa: AugmentedSubmittable<(msaOwnerPublicKey: AccountId32 | string | Uint8Array, msaOwnerProof: SpRuntimeMultiSignature | {
                Ed25519: any;
            } | {
                Sr25519: any;
            } | {
                Ecdsa: any;
            } | string | Uint8Array, newKeyOwnerProof: SpRuntimeMultiSignature | {
                Ed25519: any;
            } | {
                Sr25519: any;
            } | {
                Ecdsa: any;
            } | string | Uint8Array, addKeyPayload: PalletMsaAddKeyData | {
                msaId?: any;
                expiration?: any;
                newPublicKey?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, SpRuntimeMultiSignature, SpRuntimeMultiSignature, PalletMsaAddKeyData]>;
            /**
             * Adds a Recovery Commitment to an MSA. The Recovery Commitment is a cryptographic commitment
             * that can be used later in a recovery process to prove ownership or authorization.
             *
             * This function allows the owner of an MSA to create a Recovery Commitment hash that is stored
             * on-chain. The commitment must be signed by the MSA owner to prove authorization.
             *
             * # Remarks
             * * The `origin` can be any signed account but the `msa_owner_key` must be the actual owner
             * * Signatures should be over the [`RecoveryCommitmentPayload`] struct
             * * The Recovery Commitment is stored as a hash mapping from MSA ID to commitment value
             *
             * # Events
             * * [`Event::RecoveryCommitmentAdded`]
             *
             * # Errors
             * * [`Error::InvalidSignature`] - `proof` verification fails; `msa_owner_key` must have signed `payload`
             * * [`Error::NoKeyExists`] - there is no MSA for `msa_owner_key`
             * * [`Error::ProofNotYetValid`] - `payload` expiration is too far in the future
             * * [`Error::ProofHasExpired`] - `payload` expiration is in the past
             * * [`Error::SignatureAlreadySubmitted`] - signature has already been used
             *
             **/
            addRecoveryCommitment: AugmentedSubmittable<(msaOwnerKey: AccountId32 | string | Uint8Array, proof: SpRuntimeMultiSignature | {
                Ed25519: any;
            } | {
                Sr25519: any;
            } | {
                Ecdsa: any;
            } | string | Uint8Array, payload: PalletMsaRecoveryCommitmentPayload | {
                discriminant?: any;
                recoveryCommitment?: any;
                expiration?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, SpRuntimeMultiSignature, PalletMsaRecoveryCommitmentPayload]>;
            /**
             * Approves a recovery provider via governance.
             * Only governance can approve recovery providers.
             *
             * # Events
             * * [`Event::RecoveryProviderApproved`]
             *
             * # Errors
             * * [`DispatchError::BadOrigin`] - Caller is not authorized to approve recovery providers.
             *
             **/
            approveRecoveryProvider: AugmentedSubmittable<(providerKey: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
            /**
             * Creates an MSA for the Origin (sender of the transaction).  Origin is assigned an MSA ID.
             *
             * # Events
             * * [`Event::MsaCreated`]
             *
             * # Errors
             *
             * * [`Error::KeyAlreadyRegistered`] - MSA is already registered to the Origin.
             *
             **/
            create: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Create application allows creating an application registry without governance
             * This call is blocked in release mode
             **/
            createApplication: AugmentedSubmittable<(payload: CommonPrimitivesMsaProviderRegistryEntry | {
                defaultName?: any;
                localizedNames?: any;
                defaultLogo250100PngCid?: any;
                localizedLogo250100PngCids?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CommonPrimitivesMsaProviderRegistryEntry]>;
            /**
             * Create application via governance approval
             *
             * # Events
             * * [`Event::ApplicationCreated`]
             *
             * # Errors
             * * [`Error::NoKeyExists`] - account does not have an MSA
             * * [`Error::DuplicateApplicationRegistryEntry`] - an ApplicationRegistryEntry associated with the given MSA id already exists.
             * * [`Error::InvalidCid`] - If the provided CID is invalid.
             * * [`Error::InvalidBCP47LanguageCode`] - If the provided BCP 47 language code is invalid.
             **/
            createApplicationViaGovernance: AugmentedSubmittable<(providerKey: AccountId32 | string | Uint8Array, payload: CommonPrimitivesMsaProviderRegistryEntry | {
                defaultName?: any;
                localizedNames?: any;
                defaultLogo250100PngCid?: any;
                localizedLogo250100PngCids?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, CommonPrimitivesMsaProviderRegistryEntry]>;
            /**
             * Adds an association between MSA id and ProviderRegistryEntry. As of now, the
             * only piece of metadata we are recording is provider name.
             *
             * # Events
             * * [`Event::ProviderCreated`]
             *
             * # Errors
             * * [`Error::NoKeyExists`] - origin does not have an MSA
             * * [`Error::ExceedsMaxProviderNameSize`] - Too long of a provider name
             * * [`Error::DuplicateProviderRegistryEntry`] - a ProviderRegistryEntry associated with the given MSA id already exists.
             **/
            createProvider: AugmentedSubmittable<(providerName: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Create a provider by means of governance approval
             *
             * # Events
             * * [`Event::ProviderCreated`]
             *
             * # Errors
             * * [`Error::NoKeyExists`] - account does not have an MSA
             * * [`Error::ExceedsMaxProviderNameSize`] - Too long of a provider name
             * * [`Error::DuplicateProviderRegistryEntry`] - a ProviderRegistryEntry associated with the given MSA id already exists.
             **/
            createProviderViaGovernance: AugmentedSubmittable<(providerKey: AccountId32 | string | Uint8Array, providerName: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, Bytes]>;
            /**
             * Create a provider by means of governance approval
             *
             * # Events
             * * [`Event::ProviderCreated`]
             *
             * # Errors
             * * [`Error::NoKeyExists`] - account does not have an MSA
             * * [`Error::DuplicateProviderRegistryEntry`] - a ProviderRegistryEntry associated with the given MSA id already exists.
             * * [`Error::InvalidCid`] - If the provided CID is invalid.
             * * [`Error::InvalidBCP47LanguageCode`] - If the provided BCP 47 language code is invalid.
             **/
            createProviderViaGovernanceV2: AugmentedSubmittable<(providerKey: AccountId32 | string | Uint8Array, payload: CommonPrimitivesMsaProviderRegistryEntry | {
                defaultName?: any;
                localizedNames?: any;
                defaultLogo250100PngCid?: any;
                localizedLogo250100PngCids?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, CommonPrimitivesMsaProviderRegistryEntry]>;
            /**
             * `Origin` MSA creates an MSA on behalf of `delegator_key`, creates a Delegation with the `delegator_key`'s MSA as the Delegator and `origin` as `Provider`. Deposits events [`MsaCreated`](Event::MsaCreated) and [`DelegationGranted`](Event::DelegationGranted).
             *
             * # Remarks
             * * Origin MUST be the provider
             * * Signatures should be over the [`AddProvider`] struct
             *
             * # Events
             * * [`Event::MsaCreated`]
             * * [`Event::DelegationGranted`]
             *
             * # Errors
             *
             * * [`Error::UnauthorizedProvider`] - payload's MSA does not match given provider MSA.
             * * [`Error::InvalidSignature`] - `proof` verification fails; `delegator_key` must have signed `add_provider_payload`
             * * [`Error::NoKeyExists`] - there is no MSA for `origin`.
             * * [`Error::KeyAlreadyRegistered`] - there is already an MSA for `delegator_key`.
             * * [`Error::ProviderNotRegistered`] - the a non-provider MSA is used as the provider
             * * [`Error::ProofNotYetValid`] - `add_provider_payload` expiration is too far in the future
             * * [`Error::ProofHasExpired`] - `add_provider_payload` expiration is in the past
             * * [`Error::SignatureAlreadySubmitted`] - signature has already been used
             *
             **/
            createSponsoredAccountWithDelegation: AugmentedSubmittable<(delegatorKey: AccountId32 | string | Uint8Array, proof: SpRuntimeMultiSignature | {
                Ed25519: any;
            } | {
                Sr25519: any;
            } | {
                Ecdsa: any;
            } | string | Uint8Array, addProviderPayload: PalletMsaAddProvider | {
                authorizedMsaId?: any;
                intentIds?: any;
                expiration?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, SpRuntimeMultiSignature, PalletMsaAddProvider]>;
            /**
             * Remove a key associated with an MSA by expiring it at the current block.
             *
             * # Remarks
             * * Removal of key deletes the association of the key with the MSA.
             * * The key can be re-added to same or another MSA if needed.
             *
             * # Events
             * * [`Event::PublicKeyDeleted`]
             *
             * # Errors
             * * [`Error::InvalidSelfRemoval`] - `origin` and `key` are the same.
             * * [`Error::NotKeyOwner`] - `origin` does not own the MSA ID associated with `key`.
             * * [`Error::NoKeyExists`] - `origin` or `key` are not associated with `origin`'s MSA ID.
             *
             **/
            deleteMsaPublicKey: AugmentedSubmittable<(publicKeyToDelete: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
            /**
             * Creates a new Delegation for an existing MSA, with `origin` as the Provider and `delegator_key` is the delegator.
             * Since it is being sent on the Delegator's behalf, it requires the Delegator to authorize the new Delegation.
             *
             * # Remarks
             * * Origin MUST be the provider
             * * Signatures should be over the [`AddProvider`] struct
             *
             * # Events
             * * [`Event::DelegationGranted`]
             *
             * # Errors
             * * [`Error::AddProviderSignatureVerificationFailed`] - `origin`'s MSA ID does not equal `add_provider_payload.authorized_msa_id`.
             * * [`Error::DuplicateProvider`] - there is already a Delegation for `origin` MSA and `delegator_key` MSA.
             * * [`Error::UnauthorizedProvider`] - `add_provider_payload.authorized_msa_id`  does not match MSA ID of `delegator_key`.
             * * [`Error::InvalidSelfProvider`] - Cannot delegate to the same MSA
             * * [`Error::InvalidSignature`] - `proof` verification fails; `delegator_key` must have signed `add_provider_payload`
             * * [`Error::NoKeyExists`] - there is no MSA for `origin` or `delegator_key`.
             * * [`Error::ProviderNotRegistered`] - a non-provider MSA is used as the provider
             * * [`Error::UnauthorizedDelegator`] - Origin attempted to add a delegate for someone else's MSA
             *
             **/
            grantDelegation: AugmentedSubmittable<(delegatorKey: AccountId32 | string | Uint8Array, proof: SpRuntimeMultiSignature | {
                Ed25519: any;
            } | {
                Sr25519: any;
            } | {
                Ecdsa: any;
            } | string | Uint8Array, addProviderPayload: PalletMsaAddProvider | {
                authorizedMsaId?: any;
                intentIds?: any;
                expiration?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, SpRuntimeMultiSignature, PalletMsaAddProvider]>;
            /**
             * Propose to add application enable provider to add multiple applications on frequency.
             * Provider initiates a governance proposal to add the application.
             *
             * # Errors
             * - [`NoKeyExists`](Error::NoKeyExists) - If there is not MSA for `origin`.
             * * [`Error::InvalidCid`] - If the provided CID is invalid.
             * * [`Error::InvalidBCP47LanguageCode`] - If the provided BCP 47 language code is invalid.
             **/
            proposeToAddApplication: AugmentedSubmittable<(payload: CommonPrimitivesMsaProviderRegistryEntry | {
                defaultName?: any;
                localizedNames?: any;
                defaultLogo250100PngCid?: any;
                localizedLogo250100PngCids?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CommonPrimitivesMsaProviderRegistryEntry]>;
            /**
             * Propose to be a provider.  Creates a proposal for council approval to create a provider from a MSA
             *
             * # Errors
             * - [`NoKeyExists`](Error::NoKeyExists) - If there is not MSA for `origin`.
             * - [`Error::ExceedsMaxProviderNameSize`] - Too long of a provider name
             **/
            proposeToBeProvider: AugmentedSubmittable<(providerName: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Propose to be a provider.  Creates a proposal for council approval to create a provider from a MSA
             *
             * # Errors
             * - [`NoKeyExists`](Error::NoKeyExists) - If there is not MSA for `origin`.
             **/
            proposeToBeProviderV2: AugmentedSubmittable<(payload: CommonPrimitivesMsaProviderRegistryEntry | {
                defaultName?: any;
                localizedNames?: any;
                defaultLogo250100PngCid?: any;
                localizedLogo250100PngCids?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CommonPrimitivesMsaProviderRegistryEntry]>;
            /**
             * Propose to update application via governance for a given `ApplicationIndex`
             *
             * # Arguments
             * * `origin` - The origin of the call
             * * `application_index` - The index of the application to update
             * * `payload` - The new application data
             *
             * # Errors
             * * [`Error::NoKeyExists`] - If there is not MSA for `origin`.
             * * [`Error::ApplicationNotFound`] - If the application is not registered.
             * * [`Error::InvalidCid`] - If the provided CID is invalid.
             * * [`Error::InvalidBCP47LanguageCode`] - If the provided BCP 47 language code is invalid.
             * * [`Error::ApplicationNotFound`] - If the application is not registered.
             **/
            proposeToUpdateApplication: AugmentedSubmittable<(applicationIndex: u16 | AnyNumber | Uint8Array, payload: CommonPrimitivesMsaProviderRegistryEntry | {
                defaultName?: any;
                localizedNames?: any;
                defaultLogo250100PngCid?: any;
                localizedLogo250100PngCids?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, CommonPrimitivesMsaProviderRegistryEntry]>;
            /**
             * Propose to update provider registry via governance
             *
             * # Arguments
             * * `origin` - The origin of the call
             * * `provider_key` - The key of the provider to update
             * * `payload` - The new provider data
             *
             * # Errors
             * * [`Error::NoKeyExists`] - If there is not MSA for `origin`.
             * * [`Error::ProviderNotRegistered`] - If the provider is not registered.
             * * [`Error::InvalidCid`] - If the provided CID is invalid.
             * * [`Error::InvalidBCP47LanguageCode`] - If the provided BCP 47 language code is invalid.
             **/
            proposeToUpdateProvider: AugmentedSubmittable<(payload: CommonPrimitivesMsaProviderRegistryEntry | {
                defaultName?: any;
                localizedNames?: any;
                defaultLogo250100PngCid?: any;
                localizedLogo250100PngCids?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CommonPrimitivesMsaProviderRegistryEntry]>;
            /**
             * Recover an MSA account with a new control key.
             * This extrinsic is called by approved Recovery Providers after verifying
             * the user's Recovery Intermediary Hashes and Authentication Contact.
             *
             * # Events
             * * [`Event::AccountRecovered`]
             * * [`Event::RecoveryCommitmentInvalidated`]
             *
             * # Errors
             * * [`Error::NotAuthorizedRecoveryProvider`] - Caller is not an approved Recovery Provider.
             * * [`Error::ProviderNotRegistered`] - Recovery Provider is not registered.
             * * [`Error::NoRecoveryCommitment`] - No Recovery Commitment exists for the MSA.
             * * [`Error::InvalidRecoveryCommitment`] - Recovery Commitment does not match.
             *
             **/
            recoverAccount: AugmentedSubmittable<(intermediaryHashA: U8aFixed | string | Uint8Array, intermediaryHashB: U8aFixed | string | Uint8Array, newControlKeyProof: SpRuntimeMultiSignature | {
                Ed25519: any;
            } | {
                Sr25519: any;
            } | {
                Ecdsa: any;
            } | string | Uint8Array, addKeyPayload: PalletMsaAddKeyData | {
                msaId?: any;
                expiration?: any;
                newPublicKey?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, U8aFixed, SpRuntimeMultiSignature, PalletMsaAddKeyData]>;
            /**
             * A generic endpoint to replay any offchain related event to fix any potential issues
             **/
            reindexOffchain: AugmentedSubmittable<(event: PalletMsaOffchainStorageOffchainReplayEvent | {
                MsaPallet: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletMsaOffchainStorageOffchainReplayEvent]>;
            /**
             * Removes a recovery provider via governance.
             * Only governance can remove recovery providers.
             *
             * # Events
             * * [`Event::RecoveryProviderRemoved`]
             *
             * # Errors
             *
             * * [`DispatchError::BadOrigin`] - Caller is not authorized to remove recovery providers.
             *
             **/
            removeRecoveryProvider: AugmentedSubmittable<(provider: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
            /**
             * Retires a MSA
             *
             * When a user wants to disassociate themselves from Frequency, they can retire their MSA for free provided that:
             * (1) They own the MSA
             * (2) The MSA is not a registered provider.
             * (3) They retire their user handle (if they have one)
             * (4) There is only one account key
             * (5) The user has already deleted all delegations to providers
             *
             * This does not currently remove any messages related to the MSA.
             *
             * # Events
             * * [`Event::PublicKeyDeleted`]
             * * [`Event::MsaRetired`]
             *
             * # Errors
             * * [`Error::NoKeyExists`] - `delegator` does not have an MSA key.
             *
             **/
            retireMsa: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Delegator (Origin) MSA terminates a delegation relationship with the `Provider` MSA. Deposits event[`DelegationRevoked`](Event::DelegationRevoked).
             *
             * # Events
             * * [`Event::DelegationRevoked`]
             *
             * # Errors
             *
             * * [`Error::NoKeyExists`] - origin does not have an MSA
             * * [`Error::DelegationRevoked`] - the delegation has already been revoked.
             * * [`Error::DelegationNotFound`] - there is not delegation relationship between Origin and Delegator or Origin and Delegator are the same.
             *
             **/
            revokeDelegationByDelegator: AugmentedSubmittable<(providerMsaId: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;
            /**
             * Provider MSA terminates Delegation with a Delegator MSA by expiring the Delegation at the current block.
             *
             * # Events
             * * [`Event::DelegationRevoked`]
             *
             * # Errors
             *
             * * [`Error::NoKeyExists`] - `provider_key` does not have an MSA key.
             * * [`Error::DelegationRevoked`] - delegation is already revoked
             * * [`Error::DelegationNotFound`] - no Delegation found between origin MSA and delegator MSA.
             *
             **/
            revokeDelegationByProvider: AugmentedSubmittable<(delegator: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;
            /**
             * Update application via governance for given existing `ApplicationIndex`
             *
             * # Arguments
             * * `origin` - The origin of the call
             * * `provider_key` - The key of the provider to update
             * * `application_index` - The index of the application to update
             * * `payload` - The new application data
             *
             * # Errors
             * * [`Error::NoKeyExists`] - If there is not MSA for `origin`.
             * * [`Error::ApplicationNotFound`] - If the application is not registered.
             * * [`Error::InvalidCid`] - If the provided CID is invalid.
             * * [`Error::InvalidBCP47LanguageCode`] - If the provided BCP 47 language code is invalid.
             **/
            updateApplicationViaGovernance: AugmentedSubmittable<(providerKey: AccountId32 | string | Uint8Array, applicationIndex: u16 | AnyNumber | Uint8Array, payload: CommonPrimitivesMsaProviderRegistryEntry | {
                defaultName?: any;
                localizedNames?: any;
                defaultLogo250100PngCid?: any;
                localizedLogo250100PngCids?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, u16, CommonPrimitivesMsaProviderRegistryEntry]>;
            /**
             * Update a provider by means of governance approval
             *
             * # Events
             * * [`Event::ProviderUpdated`]
             *
             * # Errors
             * * [`Error::NoKeyExists`] - account does not have an MSA
             * * [`Error::InvalidCid`] - If the provided CID is invalid.
             * * [`Error::InvalidBCP47LanguageCode`] - If the provided BCP 47 language code is invalid.
             **/
            updateProviderViaGovernance: AugmentedSubmittable<(providerKey: AccountId32 | string | Uint8Array, payload: CommonPrimitivesMsaProviderRegistryEntry | {
                defaultName?: any;
                localizedNames?: any;
                defaultLogo250100PngCid?: any;
                localizedLogo250100PngCids?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, CommonPrimitivesMsaProviderRegistryEntry]>;
            /**
             * Upload logo bytes for a approved image in `ApprovedLogos`
             *
             * * [`Error::NoKeyExists`] - If there is not MSA for `origin`.
             * * [`Error::ProviderNotRegistered`] - If the provider is not registered.
             * * [`Error::InvalidCid`] - If the provided CID is invalid and not in approved logos.
             * * [`Error::LogoCidNotApproved`] - If the logo CID is not in the approved logos list.
             *
             **/
            uploadLogo: AugmentedSubmittable<(logoCid: Bytes | string | Uint8Array, logoBytes: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Bytes]>;
            /**
             * Withdraw all available tokens from the account associated with the MSA, to the account of the caller.
             *
             * The `origin` parameter represents the account from which the function is called and must be the account receiving the tokens.
             *
             * The function requires one signature: `msa_owner_proof`, which serve as proof that the owner of the MSA authorizes the transaction.
             *
             * The necessary information for the withdrawal authorization, the destination account and the MSA ID, are contained in the `authorization_payload` parameter of type [AddKeyData].
             * It also contains an expiration block number for the proof, ensuring it is valid and must be greater than the current block.
             *
             * # Events
             * * [`pallet_balances::Event::<T,I>::Transfer`](https://docs.rs/pallet-balances/latest/pallet_balances/pallet/enum.Event.html#variant.Transfer) - Transfer token event
             *
             * # Errors
             *
             * * [`Error::ProofHasExpired`] - the current block is less than the `expired` block number set in `AddKeyData`.
             * * [`Error::ProofNotYetValid`] - the `expired` block number set in `AddKeyData` is greater than the current block number plus mortality_block_limit().
             * * [`Error::SignatureAlreadySubmitted`] - signature has already been used.
             * * [`Error::InsufficientBalanceToWithdraw`] - the MSA account has not balance to withdraw
             * * [`Error::UnexpectedTokenTransferError`] - the token transfer failed
             *
             **/
            withdrawTokens: AugmentedSubmittable<(msaOwnerPublicKey: AccountId32 | string | Uint8Array, msaOwnerProof: SpRuntimeMultiSignature | {
                Ed25519: any;
            } | {
                Sr25519: any;
            } | {
                Ecdsa: any;
            } | string | Uint8Array, authorizationPayload: PalletMsaAuthorizedKeyData | {
                discriminant?: any;
                msaId?: any;
                expiration?: any;
                authorizedPublicKey?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, SpRuntimeMultiSignature, PalletMsaAuthorizedKeyData]>;
            /**
             * 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.
             *
             * ## Complexity
             * - `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`.
             **/
            approveAsMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], maybeTimepoint: Option<PalletMultisigTimepoint> | null | Uint8Array | PalletMultisigTimepoint | {
                height?: any;
                index?: any;
            } | string, callHash: U8aFixed | string | Uint8Array, maxWeight: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Vec<AccountId32>, Option<PalletMultisigTimepoint>, U8aFixed, SpWeightsWeightV2Weight]>;
            /**
             * 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.
             *
             * ## Complexity
             * - `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`.
             **/
            asMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], maybeTimepoint: Option<PalletMultisigTimepoint> | null | Uint8Array | PalletMultisigTimepoint | {
                height?: any;
                index?: any;
            } | string, call: Call | IMethod | string | Uint8Array, maxWeight: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Vec<AccountId32>, Option<PalletMultisigTimepoint>, Call, SpWeightsWeightV2Weight]>;
            /**
             * 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.
             *
             * ## Complexity
             * O(Z + C) where Z is the length of the call and C its execution weight.
             **/
            asMultiThreshold1: AugmentedSubmittable<(otherSignatories: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>, 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.
             *
             * ## Complexity
             * - `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.
             **/
            cancelAsMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], timepoint: PalletMultisigTimepoint | {
                height?: any;
                index?: any;
            } | string | Uint8Array, callHash: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Vec<AccountId32>, PalletMultisigTimepoint, U8aFixed]>;
            /**
             * Poke the deposit reserved for an existing multisig operation.
             *
             * The dispatch origin for this call must be _Signed_ and must be the original depositor of
             * the multisig operation.
             *
             * The transaction fee is waived if the deposit amount has changed.
             *
             * - `threshold`: The total number of approvals needed for this multisig.
             * - `other_signatories`: The accounts (other than the sender) who are part of the
             * multisig.
             * - `call_hash`: The hash of the call this deposit is reserved for.
             *
             * Emits `DepositPoked` if successful.
             **/
            pokeDeposit: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], callHash: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Vec<AccountId32>, U8aFixed]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        parachainSystem: {
            /**
             * Set the current validation data.
             *
             * This should be invoked exactly once per block. It will panic at the finalization
             * phase if the call was not invoked.
             *
             * The dispatch origin for this call must be `Inherent`
             *
             * As a side effect, this function upgrades the current validation function
             * if the appropriate time has come.
             **/
            setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | {
                validationData?: any;
                relayChainState?: any;
                downwardMessages?: any;
                horizontalMessages?: any;
                relayParentDescendants?: any;
                collatorPeerId?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;
            sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        passkey: {
            /**
             * Proxies an extrinsic call by changing the origin to `account_id` inside the payload.
             * Since this is an unsigned extrinsic all the verification checks are performed inside
             * `validate_unsigned` and `pre_dispatch` hooks.
             **/
            proxy: AugmentedSubmittable<(payload: PalletPasskeyPasskeyPayload | {
                passkeyPublicKey?: any;
                verifiablePasskeySignature?: any;
                passkeyCall?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletPasskeyPasskeyPayload]>;
            /**
             * Proxies an extrinsic call by changing the origin to `account_id` inside the payload.
             * Since this is an unsigned extrinsic all the verification checks are performed inside
             * `validate_unsigned` and `pre_dispatch` hooks.
             **/
            proxyV2: AugmentedSubmittable<(payload: PalletPasskeyPasskeyPayloadV2 | {
                passkeyPublicKey?: any;
                verifiablePasskeySignature?: any;
                accountOwnershipProof?: any;
                passkeyCall?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletPasskeyPasskeyPayloadV2]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        preimage: {
            /**
             * Ensure that the bulk of pre-images is upgraded.
             *
             * The caller pays no fee if at least 90% of pre-images were successfully updated.
             **/
            ensureUpdated: AugmentedSubmittable<(hashes: Vec<H256> | (H256 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<H256>]>;
            /**
             * Register a preimage on-chain.
             *
             * If the preimage was previously requested, no fees or deposits are taken for providing
             * the preimage. Otherwise, a deposit is taken proportional to the size of the preimage.
             **/
            notePreimage: AugmentedSubmittable<(bytes: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Request a preimage be uploaded to the chain without paying any fees or deposits.
             *
             * If the preimage requests has already been provided on-chain, we unreserve any deposit
             * a user may have paid, and take the control of the preimage out of their hands.
             **/
            requestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * Clear an unrequested preimage from the runtime storage.
             *
             * If `len` is provided, then it will be a much cheaper operation.
             *
             * - `hash`: The hash of the preimage to be removed from the store.
             * - `len`: The length of the preimage of `hash`.
             **/
            unnotePreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * Clear a previously made request for a preimage.
             *
             * NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`.
             **/
            unrequestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * 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.
             **/
            addProxy: AugmentedSubmittable<(delegate: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, proxyType: CommonRuntimeProxyProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | 'CancelProxy' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, CommonRuntimeProxyProxyType, u32]>;
            /**
             * 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.
             **/
            announce: AugmentedSubmittable<(real: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, callHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, H256]>;
            /**
             * 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.
             **/
            createPure: AugmentedSubmittable<(proxyType: CommonRuntimeProxyProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | 'CancelProxy' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array, index: u16 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [CommonRuntimeProxyProxyType, u32, u16]>;
            /**
             * Removes a previously spawned pure 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
             * `pure` with corresponding parameters.
             *
             * - `spawner`: The account that originally called `pure` to create this account.
             * - `index`: The disambiguation index originally passed to `create_pure`. Probably `0`.
             * - `proxy_type`: The proxy type originally passed to `pure`.
             * - `height`: The height of the chain when the call to `pure` was processed.
             * - `ext_index`: The extrinsic index in which the call to `pure` was processed.
             *
             * Fails with `NoPermission` in case the caller is not a previously created pure
             * account whose `pure` call has corresponding parameters.
             **/
            killPure: AugmentedSubmittable<(spawner: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, proxyType: CommonRuntimeProxyProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | 'CancelProxy' | number | Uint8Array, index: u16 | AnyNumber | Uint8Array, height: Compact<u32> | AnyNumber | Uint8Array, extIndex: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, CommonRuntimeProxyProxyType, u16, Compact<u32>, Compact<u32>]>;
            /**
             * Poke / Adjust deposits made for proxies and announcements based on current values.
             * This can be used by accounts to possibly lower their locked amount.
             *
             * The dispatch origin for this call must be _Signed_.
             *
             * The transaction fee is waived if the deposit amount has changed.
             *
             * Emits `DepositPoked` if successful.
             **/
            pokeDeposit: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Dispatch the given `call` from an account that the sender is authorised for through
             * `add_proxy`.
             *
             * 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.
             **/
            proxy: AugmentedSubmittable<(real: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, forceProxyType: Option<CommonRuntimeProxyProxyType> | null | Uint8Array | CommonRuntimeProxyProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | 'CancelProxy' | number, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Option<CommonRuntimeProxyProxyType>, 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.
             **/
            proxyAnnounced: AugmentedSubmittable<(delegate: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, real: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, forceProxyType: Option<CommonRuntimeProxyProxyType> | null | Uint8Array | CommonRuntimeProxyProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | 'CancelProxy' | number, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, Option<CommonRuntimeProxyProxyType>, 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.
             **/
            rejectAnnouncement: AugmentedSubmittable<(delegate: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, callHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, H256]>;
            /**
             * 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.
             **/
            removeAnnouncement: AugmentedSubmittable<(real: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, callHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, H256]>;
            /**
             * 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 `pure`, however if done, then
             * the unreserved fees will be inaccessible. **All access to this account will be lost.**
             **/
            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.
             **/
            removeProxy: AugmentedSubmittable<(delegate: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, proxyType: CommonRuntimeProxyProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | 'CancelProxy' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, CommonRuntimeProxyProxyType, u32]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        scheduler: {
            /**
             * Cancel an anonymously scheduled task.
             **/
            cancel: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;
            /**
             * Cancel a named scheduled task.
             **/
            cancelNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed]>;
            /**
             * Removes the retry configuration of a task.
             **/
            cancelRetry: AugmentedSubmittable<(task: ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array]) => SubmittableExtrinsic<ApiType>, [ITuple<[u32, u32]>]>;
            /**
             * Cancel the retry configuration of a named task.
             **/
            cancelRetryNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed]>;
            /**
             * Anonymously schedule a task.
             **/
            schedule: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Option<ITuple<[u32, u32]>>, u8, Call]>;
            /**
             * Anonymously schedule a task after a delay.
             **/
            scheduleAfter: AugmentedSubmittable<(after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Option<ITuple<[u32, u32]>>, u8, Call]>;
            /**
             * Schedule a named task.
             **/
            scheduleNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, Call]>;
            /**
             * Schedule a named task after a delay.
             **/
            scheduleNamedAfter: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, Call]>;
            /**
             * Set a retry configuration for a task so that, in case its scheduled run fails, it will
             * be retried after `period` blocks, for a total amount of `retries` retries or until it
             * succeeds.
             *
             * Tasks which need to be scheduled for a retry are still subject to weight metering and
             * agenda space, same as a regular task. If a periodic task fails, it will be scheduled
             * normally while the task is retrying.
             *
             * Tasks scheduled as a result of a retry for a periodic task are unnamed, non-periodic
             * clones of the original task. Their retry configuration will be derived from the
             * original task's configuration, but will have a lower value for `remaining` than the
             * original `total_retries`.
             **/
            setRetry: AugmentedSubmittable<(task: ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], retries: u8 | AnyNumber | Uint8Array, period: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [ITuple<[u32, u32]>, u8, u32]>;
            /**
             * Set a retry configuration for a named task so that, in case its scheduled run fails, it
             * will be retried after `period` blocks, for a total amount of `retries` retries or until
             * it succeeds.
             *
             * Tasks which need to be scheduled for a retry are still subject to weight metering and
             * agenda space, same as a regular task. If a periodic task fails, it will be scheduled
             * normally while the task is retrying.
             *
             * Tasks scheduled as a result of a retry for a periodic task are unnamed, non-periodic
             * clones of the original task. Their retry configuration will be derived from the
             * original task's configuration, but will have a lower value for `remaining` than the
             * original `total_retries`.
             **/
            setRetryNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, retries: u8 | AnyNumber | Uint8Array, period: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u8, u32]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        schemas: {
            /**
             * Creates a new Intent with a name (testnet)
             *
             * # Events
             * * [`Event::IntentCreated`]
             *
             * # Errors
             * * [`Error::IntentCountOverflow`] - The Intent count has exceeded its bounds
             * * [`Error::InvalidSetting`] - Invalid setting is provided
             * * [`Error::NameAlreadyExists`] - The name already exists
             * * [`Error::InvalidSchemaNameEncoding`] - The name has an invalid encoding
             * * [`Error::InvalidSchemaNameCharacters`] - The name contains invalid characters
             * * [`Error::InvalidSchemaNameStructure`] - The name has an invalid structure (i.e., not `protocol.descriptor`)
             * * [`Error::InvalidSchemaNameLength`] - The name exceeds the allowed overall name length
             * * [`Error::InvalidSchemaNamespaceLength`] - The protocol portion of the name exceeds the max allowed length
             * * [`Error::InvalidSchemaDescriptorLength`] - The descriptor portion of the name exceeds the max allowed length
             *
             **/
            createIntent: AugmentedSubmittable<(intentName: Bytes | string | Uint8Array, payloadLocation: CommonPrimitivesSchemaPayloadLocation | 'OnChain' | 'IPFS' | 'Itemized' | 'Paginated' | 'OffChain' | number | Uint8Array, settings: Vec<CommonPrimitivesSchemaSchemaSetting> | (CommonPrimitivesSchemaSchemaSetting | 'AppendOnly' | 'SignatureRequired' | number | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Bytes, CommonPrimitivesSchemaPayloadLocation, Vec<CommonPrimitivesSchemaSchemaSetting>]>;
            /**
             * Create an intent group (testnet)
             *
             * # Events
             * * [`Event::IntentGroupCreated`]
             *
             * # Errors
             * * [`Error::IntentGroupCountOverflow`] - The Intent Group count has exceeded its bounds.
             * * [`Error::NameAlreadyExists`] - The name already exists.
             * * [`Error::InvalidSchemaNameEncoding`] - The name has an invalid encoding.
             * * [`Error::InvalidSchemaNameCharacters`] - The name contains invalid characters.
             * * [`Error::InvalidSchemaNameStructure`] - The name has an invalid structure (i.e., not `protocol.descriptor`).
             * * [`Error::InvalidSchemaNameLength`] - The name exceeds the allowed overall name length.
             * * [`Error::InvalidSchemaNamespaceLength`] - The protocol portion of the name exceeds the max allowed length.
             * * [`Error::InvalidSchemaDescriptorLength`] - The descriptor portion of the name exceeds the max allowed length.
             * * [`Error::InvalidIntentId`] - At least one of the specified [`IntentId`]s does not exist.
             *
             **/
            createIntentGroup: AugmentedSubmittable<(intentGroupName: Bytes | string | Uint8Array, intentIds: Vec<u16> | (u16 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Bytes, Vec<u16>]>;
            /**
             * Create an IntentGroup by means of council approval
             *
             * # Events
             * * [`Event::IntentGroupCreated`]
             *
             * # Errors
             * * [`Error::IntentGroupCountOverflow`] - The Intent Group count has exceeded its bounds
             * * [`Error::NameAlreadyExists`] - The name already exists.
             * * [`Error::InvalidSchemaNameEncoding`] - The name has an invalid encoding.
             * * [`Error::InvalidSchemaNameCharacters`] - The name contains invalid characters.
             * * [`Error::InvalidSchemaNameStructure`] - The name has an invalid structure (i.e., not `protocol.descriptor`).
             * * [`Error::InvalidSchemaNameLength`] - The name exceeds the allowed overall name length.
             * * [`Error::InvalidSchemaNamespaceLength`] - The protocol portion of the name exceeds the max allowed length.
             * * [`Error::InvalidSchemaDescriptorLength`] - The descriptor portion of the name exceeds the max allowed length.
             * * [`Error::InvalidIntentId`] - At least one of the specified [`IntentId`]s does not exist
             *
             **/
            createIntentGroupViaGovernance: AugmentedSubmittable<(creatorKey: AccountId32 | string | Uint8Array, intentGroupName: Bytes | string | Uint8Array, intentIds: Vec<u16> | (u16 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [AccountId32, Bytes, Vec<u16>]>;
            /**
             * Create an Intent by means of council approval
             *
             * # Events
             * * [`Event::IntentCreated`]
             *
             * # Errors
             * * [`Error::IntentCountOverflow`] - The Intent count has exceeded its bounds
             * * [`Error::InvalidSetting`] - Invalid setting is provided
             * * [`Error::NameAlreadyExists`] - The name already exists
             * * [`Error::InvalidSchemaNameEncoding`] - The name has an invalid encoding
             * * [`Error::InvalidSchemaNameCharacters`] - The name contains invalid characters
             * * [`Error::InvalidSchemaNameStructure`] - The name has an invalid structure (i.e., not `protocol.descriptor`)
             * * [`Error::InvalidSchemaNameLength`] - The name exceeds the allowed overall name length
             * * [`Error::InvalidSchemaNamespaceLength`] - The protocol portion of the name exceeds the max allowed length
             * * [`Error::InvalidSchemaDescriptorLength`] - The descriptor portion of the name exceeds the max allowed length
             *
             **/
            createIntentViaGovernance: AugmentedSubmittable<(creatorKey: AccountId32 | string | Uint8Array, payloadLocation: CommonPrimitivesSchemaPayloadLocation | 'OnChain' | 'IPFS' | 'Itemized' | 'Paginated' | 'OffChain' | number | Uint8Array, settings: Vec<CommonPrimitivesSchemaSchemaSetting> | (CommonPrimitivesSchemaSchemaSetting | 'AppendOnly' | 'SignatureRequired' | number | Uint8Array)[], intentName: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, CommonPrimitivesSchemaPayloadLocation, Vec<CommonPrimitivesSchemaSchemaSetting>, Bytes]>;
            /**
             * Adds a given schema to storage. (testnet)
             *
             * The schema in question must be of length
             * between the min and max model size allowed for schemas (see pallet
             * constants above). If the pallet's maximum schema limit has been
             * fulfilled by the time this extrinsic is called, a SchemaCountOverflow error
             * will be thrown.
             *
             * # Events
             * * [`Event::SchemaCreated`]
             *
             * # Errors
             * * [`Error::LessThanMinSchemaModelBytes`] - The schema's length is less than the minimum schema length
             * * [`Error::ExceedsMaxSchemaModelBytes`] - The schema's length is greater than the maximum schema length
             * * [`Error::InvalidSchema`] - Schema is malformed in some way
             * * [`Error::SchemaCountOverflow`] - The schema count has exceeded its bounds
             *
             **/
            createSchemaV4: AugmentedSubmittable<(intentId: u16 | AnyNumber | Uint8Array, model: Bytes | string | Uint8Array, modelType: CommonPrimitivesSchemaModelType | 'AvroBinary' | 'Parquet' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Bytes, CommonPrimitivesSchemaModelType]>;
            /**
             * Create a schema by means of council approval
             *
             * # Events
             * * [`Event::SchemaCreated`]
             *
             * # Errors
             * * [`Error::LessThanMinSchemaModelBytes`] - The schema's length is less than the minimum schema length
             * * [`Error::ExceedsMaxSchemaModelBytes`] - The schema's length is greater than the maximum schema length
             * * [`Error::InvalidSchema`] - Schema is malformed in some way
             * * [`Error::SchemaCountOverflow`] - The schema count has exceeded its bounds
             *
             **/
            createSchemaViaGovernanceV3: AugmentedSubmittable<(creatorKey: AccountId32 | string | Uint8Array, intentId: u16 | AnyNumber | Uint8Array, model: Bytes | string | Uint8Array, modelType: CommonPrimitivesSchemaModelType | 'AvroBinary' | 'Parquet' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, u16, Bytes, CommonPrimitivesSchemaModelType]>;
            /**
             * Propose to create an Intent.  Creates a proposal for council approval to create an Intent
             *
             **/
            proposeToCreateIntent: AugmentedSubmittable<(payloadLocation: CommonPrimitivesSchemaPayloadLocation | 'OnChain' | 'IPFS' | 'Itemized' | 'Paginated' | 'OffChain' | number | Uint8Array, settings: Vec<CommonPrimitivesSchemaSchemaSetting> | (CommonPrimitivesSchemaSchemaSetting | 'AppendOnly' | 'SignatureRequired' | number | Uint8Array)[], intentName: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CommonPrimitivesSchemaPayloadLocation, Vec<CommonPrimitivesSchemaSchemaSetting>, Bytes]>;
            /**
             * Propose to create an Intent Group. Creates a proposal for council approval to create an Intent Group.
             *
             **/
            proposeToCreateIntentGroup: AugmentedSubmittable<(intentGroupName: Bytes | string | Uint8Array, intentIds: Vec<u16> | (u16 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Bytes, Vec<u16>]>;
            /**
             * Propose to create a schema.  Creates a proposal for council approval to create a schema
             *
             **/
            proposeToCreateSchemaV3: AugmentedSubmittable<(intentId: u16 | AnyNumber | Uint8Array, model: Bytes | string | Uint8Array, modelType: CommonPrimitivesSchemaModelType | 'AvroBinary' | 'Parquet' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Bytes, CommonPrimitivesSchemaModelType]>;
            /**
             * Propose to update an Intent Group. Creates a proposal for council approval to update an existing Intent Group.
             *
             **/
            proposeToUpdateIntentGroup: AugmentedSubmittable<(intentGroupId: u16 | AnyNumber | Uint8Array, intentIds: Vec<u16> | (u16 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u16, Vec<u16>]>;
            /**
             * REMOVED create_schema() at call index 0
             * Root and Governance can set a new max value for Schema bytes.
             * Must be <= the limit of the Schema BoundedVec used for registration.
             *
             * # Requires
             * * Root Origin
             *
             * # Events
             * * [`Event::SchemaMaxSizeChanged`]
             *
             * # Errors
             * * [`Error::ExceedsMaxSchemaModelBytes`] - Cannot set to above the hard coded maximum [`Config::SchemaModelMaxBytesBoundedVecLimit`]
             *
             **/
            setMaxSchemaModelBytes: AugmentedSubmittable<(maxSize: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
            /**
             * Update an [`IntentGroup`] (testnet)
             * Replaces an IntentGroup's list of Intents with a new list.
             *
             * # Events
             * * [`Event::IntentGroupUpdated`]
             *
             * # Errors
             * * [`Error::InvalidIntentGroupId`] - The specified [`IntentGroupId`] does not exist.
             * * [`Error::InvalidIntentId`] - At least one of the specified [`IntentId`]s does not exist.
             * * [`Error::TooManyIntentsInGroup`] - The update would result in too many Intents in the group.
             **/
            updateIntentGroup: AugmentedSubmittable<(intentGroupId: u16 | AnyNumber | Uint8Array, intentIds: Vec<u16> | (u16 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u16, Vec<u16>]>;
            /**
             * Update an IntentGroup by means of council approval.
             * Replaces an IntentGroup's list of Intents with a new list.
             *
             * # Events
             * * [`Event::IntentGroupUpdated`]
             *
             * # Errors
             * * [`Error::InvalidIntentGroupId`] - The specified [`IntentGroupId`] does not exist.
             * * [`Error::InvalidIntentId`] - At least one of the specified [`IntentId`]s does not exist.
             * * [`Error::TooManyIntentsInGroup`] - The update would result in too many Intents in the group.
             *
             **/
            updateIntentGroupViaGovernance: AugmentedSubmittable<(updaterKey: AccountId32 | string | Uint8Array, intentGroupId: u16 | AnyNumber | Uint8Array, intentIds: Vec<u16> | (u16 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [AccountId32, u16, Vec<u16>]>;
            /**
             * 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 and the account must be either be
             * convertible to a validator ID using the chain's typical addressing system (this usually
             * means being a controller account) or directly convertible into a validator ID (which
             * usually means being a stash account).
             *
             * ## Complexity
             * - `O(1)` in number of key types. Actual cost depends on the number of length of
             * `T::Keys::key_ids()` which is fixed.
             **/
            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.
             *
             * ## Complexity
             * - `O(1)`. Actual cost depends on the number of length of `T::Keys::key_ids()` which is
             * fixed.
             **/
            setKeys: AugmentedSubmittable<(keys: FrequencyRuntimeSessionKeys | {
                aura?: any;
            } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [FrequencyRuntimeSessionKeys, Bytes]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        statefulStorage: {
            /**
             * Applies the Add or Delete Actions on the requested Itemized page.
             * This is treated as a transaction so either all actions succeed or none will be executed.
             *
             * Note: if called by the state owner, call may succeed even on `SignatureRequired` schemas.
             * The fact that the entire (signed) transaction is submitted by the owner's keypair is
             * considered equivalent to supplying a separate signature. Note in that case that a delegate
             * submitting this extrinsic on behalf of a user would fail.
             *
             * # Events
             * * [`Event::ItemizedPageUpdated`]
             * * [`Event::ItemizedPageDeleted`]
             *
             **/
            applyItemActions: AugmentedSubmittable<(stateOwnerMsaId: Compact<u64> | AnyNumber | Uint8Array, schemaId: Compact<u16> | AnyNumber | Uint8Array, targetHash: Compact<u32> | AnyNumber | Uint8Array, actions: Vec<PalletStatefulStorageItemAction> | (PalletStatefulStorageItemAction | {
                Add: any;
            } | {
                Delete: any;
            } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Compact<u64>, Compact<u16>, Compact<u32>, Vec<PalletStatefulStorageItemAction>]>;
            /**
             * Applies the Add or Delete Actions on the requested Itemized page that requires signature
             * since the signature of delegator is checked there is no need for delegation validation
             * This is treated as a transaction so either all actions succeed or none will be executed.
             *
             * # Events
             * * [`Event::ItemizedPageUpdated`]
             * * [`Event::ItemizedPageDeleted`]
             *
             **/
            applyItemActionsWithSignatureV2: AugmentedSubmittable<(delegatorKey: AccountId32 | string | Uint8Array, proof: SpRuntimeMultiSignature | {
                Ed25519: any;
            } | {
                Sr25519: any;
            } | {
                Ecdsa: any;
            } | string | Uint8Array, payload: PalletStatefulStorageItemizedSignaturePayloadV2 | {
                schemaId?: any;
                targetHash?: any;
                expiration?: any;
                actions?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, SpRuntimeMultiSignature, PalletStatefulStorageItemizedSignaturePayloadV2]>;
            /**
             * Deletes a Paginated storage
             *
             * Note: if called by the state owner, call may succeed even on `SignatureRequired` schemas.
             * The fact that the entire (signed) transaction is submitted by the owner's keypair is
             * considered equivalent to supplying a separate signature. Note in that case that a delegate
             * submitting this extrinsic on behalf of a user would fail.
             *
             * # Events
             * * [`Event::PaginatedPageDeleted`]
             *
             **/
            deletePage: AugmentedSubmittable<(stateOwnerMsaId: Compact<u64> | AnyNumber | Uint8Array, schemaId: Compact<u16> | AnyNumber | Uint8Array, pageId: Compact<u16> | AnyNumber | Uint8Array, targetHash: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>, Compact<u16>, Compact<u16>, Compact<u32>]>;
            /**
             * Deletes a Paginated storage that requires signature
             * since the signature of delegator is checked there is no need for delegation validation
             *
             * # Events
             * * [`Event::PaginatedPageDeleted`]
             *
             **/
            deletePageWithSignatureV2: AugmentedSubmittable<(delegatorKey: AccountId32 | string | Uint8Array, proof: SpRuntimeMultiSignature | {
                Ed25519: any;
            } | {
                Sr25519: any;
            } | {
                Ecdsa: any;
            } | string | Uint8Array, payload: PalletStatefulStoragePaginatedDeleteSignaturePayloadV2 | {
                schemaId?: any;
                pageId?: any;
                targetHash?: any;
                expiration?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, SpRuntimeMultiSignature, PalletStatefulStoragePaginatedDeleteSignaturePayloadV2]>;
            /**
             * Creates or updates a Paginated page with new payload
             *
             * Note: if called by the state owner, call may succeed even on `SignatureRequired` schemas.
             * The fact that the entire (signed) transaction is submitted by the owner's keypair is
             * considered equivalent to supplying a separate signature. Note in that case that a delegate
             * submitting this extrinsic on behalf of a user would fail.
             *
             * # Events
             * * [`Event::PaginatedPageUpdated`]
             *
             **/
            upsertPage: AugmentedSubmittable<(stateOwnerMsaId: Compact<u64> | AnyNumber | Uint8Array, schemaId: Compact<u16> | AnyNumber | Uint8Array, pageId: Compact<u16> | AnyNumber | Uint8Array, targetHash: Compact<u32> | AnyNumber | Uint8Array, payload: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>, Compact<u16>, Compact<u16>, Compact<u32>, Bytes]>;
            /**
             * Creates or updates Paginated storage with new payload that requires signature.
             * Since the signature of delegator is checked, there is no need for delegation validation.
             *
             * # Events
             * * [`Event::PaginatedPageUpdated`]
             *
             **/
            upsertPageWithSignatureV2: AugmentedSubmittable<(delegatorKey: AccountId32 | string | Uint8Array, proof: SpRuntimeMultiSignature | {
                Ed25519: any;
            } | {
                Sr25519: any;
            } | {
                Ecdsa: any;
            } | string | Uint8Array, payload: PalletStatefulStoragePaginatedUpsertSignaturePayloadV2 | {
                schemaId?: any;
                pageId?: any;
                targetHash?: any;
                expiration?: any;
                payload?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, SpRuntimeMultiSignature, PalletStatefulStoragePaginatedUpsertSignaturePayloadV2]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        sudo: {
            /**
             * Permanently removes the sudo key.
             *
             * **This cannot be un-done.**
             **/
            removeKey: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo
             * key.
             **/
            setKey: AugmentedSubmittable<(updated: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;
            /**
             * Authenticates the sudo key and dispatches a function call with `Root` origin.
             **/
            sudo: AugmentedSubmittable<(call: Call | IMethod | 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_.
             **/
            sudoAs: AugmentedSubmittable<(who: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, 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_.
             **/
            sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        system: {
            /**
             * Provide the preimage (runtime binary) `code` for an upgrade that has been authorized.
             *
             * If the authorization required a version check, this call will ensure the spec name
             * remains unchanged and that the spec version has increased.
             *
             * Depending on the runtime's `OnSetCode` configuration, this function may directly apply
             * the new `code` in the same block or attempt to schedule the upgrade.
             *
             * All origins are allowed.
             **/
            applyAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied
             * later.
             *
             * This call requires Root origin.
             **/
            authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied
             * later.
             *
             * WARNING: This authorizes an upgrade that will take place without any safety checks, for
             * example that the spec name remains the same and that the version number increases. Not
             * recommended for normal use. Use `authorize_upgrade` instead.
             *
             * This call requires Root origin.
             **/
            authorizeUpgradeWithoutChecks: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * 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.
             **/
            killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;
            /**
             * Kill some items from storage.
             **/
            killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;
            /**
             * Make some on-chain remark.
             *
             * Can be executed by every `origin`.
             **/
            remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Make some on-chain remark and emit event.
             **/
            remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Set the new runtime code.
             **/
            setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Set the new runtime code without doing any checks of the given `code`.
             *
             * Note that runtime upgrades will not run if this is called with a not-increasing spec
             * version!
             **/
            setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
            /**
             * Set the number of pages in the WebAssembly environment's heap.
             **/
            setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
            /**
             * Set some items of storage.
             **/
            setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        technicalCommittee: {
            /**
             * 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.
             *
             * ## Complexity
             * - `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)
             **/
            close: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, index: Compact<u32> | AnyNumber | Uint8Array, proposalWeightBound: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, Compact<u32>, SpWeightsWeightV2Weight, 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.
             *
             * ## Complexity
             * O(P) where P is the number of max proposals
             **/
            disapproveProposal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * Dispatch a proposal from a member using the `Member` origin.
             *
             * Origin must be a member of the collective.
             *
             * ## Complexity:
             * - `O(B + M + P)` where:
             * - `B` is `proposal` size in bytes (length-fee-bounded)
             * - `M` members-count (code-bounded)
             * - `P` complexity of dispatching `proposal`
             **/
            execute: AugmentedSubmittable<(proposal: Call | IMethod | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, Compact<u32>]>;
            /**
             * Disapprove the proposal and burn the cost held for storing this proposal.
             *
             * Parameters:
             * - `origin`: must be the `KillOrigin`.
             * - `proposal_hash`: The hash of the proposal that should be killed.
             *
             * Emits `Killed` and `ProposalCostBurned` if any cost was held for a given proposal.
             **/
            kill: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * 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.
             *
             * ## Complexity
             * - `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`)
             **/
            propose: AugmentedSubmittable<(threshold: Compact<u32> | AnyNumber | Uint8Array, proposal: Call | IMethod | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Call, Compact<u32>]>;
            /**
             * Release the cost held for storing a proposal once the given proposal is completed.
             *
             * If there is no associated cost for the given proposal, this call will have no effect.
             *
             * Parameters:
             * - `origin`: must be `Signed` or `Root`.
             * - `proposal_hash`: The hash of the proposal.
             *
             * Emits `ProposalCostReleased` if any cost held for a given proposal.
             **/
            releaseProposalCost: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
            /**
             * 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.
             *
             * The dispatch of this call must be `SetMembersOrigin`.
             *
             * NOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but
             * the weight estimations rely on it to estimate dispatchable weight.
             *
             * # WARNING:
             *
             * The `pallet-collective` can also be managed by logic outside of the pallet through the
             * implementation of the trait [`ChangeMembers`].
             * Any call to `set_members` must be careful that the member set doesn't get out of sync
             * with other logic managing the member set.
             *
             * ## Complexity:
             * - `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)
             **/
            setMembers: AugmentedSubmittable<(newMembers: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], prime: Option<AccountId32> | null | Uint8Array | AccountId32 | string, oldCount: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>, Option<AccountId32>, u32]>;
            /**
             * 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.
             * ## Complexity
             * - `O(M)` where `M` is members-count (code- and governance-bounded)
             **/
            vote: AugmentedSubmittable<(proposal: H256 | string | Uint8Array, index: Compact<u32> | AnyNumber | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, Compact<u32>, bool]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        timeRelease: {
            /**
             * Cancels a scheduled transfer by its unique identifier.
             * Releases any funds held for the specified transfer.
             **/
            cancelScheduledNamedTransfer: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed]>;
            /**
             * Claim thawed balances.
             *
             * # Events
             * * [`Event::Claimed`]
             *
             **/
            claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
            /**
             * Claim thawed balances on behalf for an account.
             *
             * # Events
             * * [`Event::Claimed`]
             *
             **/
            claimFor: AugmentedSubmittable<(dest: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;
            /**
             * Execute a scheduled transfer
             *
             * This function is called to execute a transfer that was previously scheduled.
             * It ensures that the origin is valid, the destination account exists, and the
             * release schedule is valid. It then finalizes the vesting transfer from the
             * hold balance and emits an event indicating that the release schedule was added.
             *
             * # Arguments
             *
             * * `origin` - The origin of the call, which must be the TimeRelease origin.
             * * `dest` - The destination account to which the funds will be transferred.
             * * `schedule` - The release schedule that specifies the amount and timing of the transfer.
             *
             * # Errors
             *
             * * [`ArithmeticError::Overflow`] - If the total amount in the schedule overflows.
             * * [`Error::InsufficientBalanceToFreeze`] - If the hold balance is insufficient.
             * * [`Error::ZeroReleasePeriod`] - If the release period is zero.
             * * [`Error::ZeroReleasePeriodCount`] - If the release period count is zero.
             * * [`Error::AmountLow`] - If the total amount is below the minimum release transfer amount.
             *
             * # Events
             *
             * * [`Event::ReleaseScheduleAdded`] - Indicates that a new release schedule was added.
             **/
            executeScheduledNamedTransfer: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, dest: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, schedule: PalletTimeReleaseReleaseSchedule | {
                start?: any;
                period?: any;
                periodCount?: any;
                perPeriod?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, MultiAddress, PalletTimeReleaseReleaseSchedule]>;
            /**
             * This function schedules a transfer by calling the `Scheduler` pallet's `schedule` function.
             * The transfer will be executed at the specified block number.
             *
             * * [`Error::InsufficientBalanceToFreeze`] - Insufficient amount of balance to freeze.
             * * [`Error::MaxReleaseSchedulesExceeded`] - Failed because the maximum release schedules was exceeded-
             * * [`ArithmeticError::Overflow] - Failed because of an overflow.
             *
             **/
            scheduleNamedTransfer: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, dest: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, schedule: PalletTimeReleaseReleaseSchedule | {
                start?: any;
                period?: any;
                periodCount?: any;
                perPeriod?: any;
            } | string | Uint8Array, when: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, MultiAddress, PalletTimeReleaseReleaseSchedule, u32]>;
            /**
             * Add a new release schedule for an account.
             *
             * # Events
             * * [`Event::ReleaseScheduleAdded]
             *
             * # Errors
             *
             * * [`Error::InsufficientBalanceToFreeze] - Insufficient amount of balance to freeze.
             * * [`Error::MaxReleaseSchedulesExceeded] - Failed because the maximum release schedules was exceeded-
             * * [`ArithmeticError::Overflow] - Failed because of an overflow.
             *
             **/
            transfer: AugmentedSubmittable<(dest: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, schedule: PalletTimeReleaseReleaseSchedule | {
                start?: any;
                period?: any;
                periodCount?: any;
                perPeriod?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletTimeReleaseReleaseSchedule]>;
            /**
             * Update all release schedules under an account, `root` origin required.
             *
             * # Events
             * * [`Event::ReleaseSchedulesUpdated] - Updated release schedules.
             *
             * # Errors
             *
             * * [`Error::InsufficientBalanceToFreeze] - Insufficient amount of balance to freeze.
             * * [`Error::MaxReleaseSchedulesExceeded] - Failed because the maximum release schedules was exceeded-
             * * [`ArithmeticError::Overflow] - Failed because of an overflow.
             *
             **/
            updateReleaseSchedules: AugmentedSubmittable<(who: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array, releaseSchedules: Vec<PalletTimeReleaseReleaseSchedule> | (PalletTimeReleaseReleaseSchedule | {
                start?: any;
                period?: any;
                periodCount?: any;
                perPeriod?: any;
            } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [MultiAddress, Vec<PalletTimeReleaseReleaseSchedule>]>;
            /**
             * 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
             * [`Config::MinimumPeriod`].
             *
             * The dispatch origin for this call must be _None_.
             *
             * This dispatch class is _Mandatory_ to ensure it gets executed in the block. Be aware
             * that changing the complexity of this call could result exhausting the resources in a
             * block to execute any other calls.
             *
             * ## Complexity
             * - `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)`.
             **/
            set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
        treasury: {
            /**
             * Approve a proposal.
             *
             * ## Dispatch Origin
             *
             * Must be [`Config::ApproveOrigin`].
             *
             * ## Details
             *
             * At a later time, the proposal will be allocated to the beneficiary and the original
             * deposit will be returned.
             *
             * ### Complexity
             * - O(1).
             *
             * ## Events
             *
             * No events are emitted from this dispatch.
             **/
            approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
            /**
             * Check the status of the spend and remove it from the storage if processed.
             *
             * ## Dispatch Origin
             *
             * Must be signed.
             *
             * ## Details
             *
             * The status check is a prerequisite for retrying a failed payout.
             * If a spend has either succeeded or expired, it is removed from the storage by this
             * function. In such instances, transaction fees are refunded.
             *
             * ### Parameters
             * - `index`: The spend index.
             *
             * ## Events
             *
             * Emits [`Event::PaymentFailed`] if the spend payout has failed.
             * Emits [`Event::SpendProcessed`] if the spend payout has succeed.
             **/
            checkStatus: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * Claim a spend.
             *
             * ## Dispatch Origin
             *
             * Must be signed.
             *
             * ## Details
             *
             * Spends must be claimed within some temporal bounds. A spend may be claimed within one
             * [`Config::PayoutPeriod`] from the `valid_from` block.
             * In case of a payout failure, the spend status must be updated with the `check_status`
             * dispatchable before retrying with the current function.
             *
             * ### Parameters
             * - `index`: The spend index.
             *
             * ## Events
             *
             * Emits [`Event::Paid`] if successful.
             **/
            payout: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * Put forward a suggestion for spending.
             *
             * ## Dispatch Origin
             *
             * Must be signed.
             *
             * ## Details
             * A deposit proportional to the value is reserved and slashed if the proposal is rejected.
             * It is returned once the proposal is awarded.
             *
             * ### Complexity
             * - O(1)
             *
             * ## Events
             *
             * Emits [`Event::Proposed`] if successful.
             **/
            proposeSpend: AugmentedSubmittable<(value: Compact<u128> | AnyNumber | Uint8Array, beneficiary: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>, MultiAddress]>;
            /**
             * Reject a proposed spend.
             *
             * ## Dispatch Origin
             *
             * Must be [`Config::RejectOrigin`].
             *
             * ## Details
             * The original deposit will be slashed.
             *
             * ### Complexity
             * - O(1)
             *
             * ## Events
             *
             * Emits [`Event::Rejected`] if successful.
             **/
            rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
            /**
             * Force a previously approved proposal to be removed from the approval queue.
             *
             * ## Dispatch Origin
             *
             * Must be [`Config::RejectOrigin`].
             *
             * ## Details
             *
             * The original deposit will no longer be returned.
             *
             * ### Parameters
             * - `proposal_id`: The index of a proposal
             *
             * ### Complexity
             * - O(A) where `A` is the number of approvals
             *
             * ### Errors
             * - [`Error::ProposalNotApproved`]: The `proposal_id` supplied was not found in the
             * approval queue, i.e., the proposal has not been approved. This could also mean the
             * proposal does not exist altogether, thus there is no way it would have been approved
             * in the first place.
             **/
            removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
            /**
             * Propose and approve a spend of treasury funds.
             *
             * ## Dispatch Origin
             *
             * Must be [`Config::SpendOrigin`] with the `Success` value being at least
             * `amount` of `asset_kind` in the native asset. The amount of `asset_kind` is converted
             * for assertion using the [`Config::BalanceConverter`].
             *
             * ## Details
             *
             * Create an approved spend for transferring a specific `amount` of `asset_kind` to a
             * designated beneficiary. The spend must be claimed using the `payout` dispatchable within
             * the [`Config::PayoutPeriod`].
             *
             * ### Parameters
             * - `asset_kind`: An indicator of the specific asset class to be spent.
             * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.
             * - `beneficiary`: The beneficiary of the spend.
             * - `valid_from`: The block number from which the spend can be claimed. It can refer to
             * the past if the resulting spend has not yet expired according to the
             * [`Config::PayoutPeriod`]. If `None`, the spend can be claimed immediately after
             * approval.
             *
             * ## Events
             *
             * Emits [`Event::AssetSpendApproved`] if successful.
             **/
            spend: AugmentedSubmittable<(assetKind: Null | null, amount: Compact<u128> | AnyNumber | Uint8Array, beneficiary: AccountId32 | string | Uint8Array, validFrom: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Null, Compact<u128>, AccountId32, Option<u32>]>;
            /**
             * Propose and approve a spend of treasury funds.
             *
             * ## Dispatch Origin
             *
             * Must be [`Config::SpendOrigin`] with the `Success` value being at least `amount`.
             *
             * ### Details
             * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the
             * beneficiary.
             *
             * ### Parameters
             * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.
             * - `beneficiary`: The destination account for the transfer.
             *
             * ## Events
             *
             * Emits [`Event::SpendApproved`] if successful.
             **/
            spendLocal: AugmentedSubmittable<(amount: Compact<u128> | AnyNumber | Uint8Array, beneficiary: MultiAddress | {
                Id: any;
            } | {
                Index: any;
            } | {
                Raw: any;
            } | {
                Address32: any;
            } | {
                Address20: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>, MultiAddress]>;
            /**
             * Void previously approved spend.
             *
             * ## Dispatch Origin
             *
             * Must be [`Config::RejectOrigin`].
             *
             * ## Details
             *
             * A spend void is only possible if the payout has not been attempted yet.
             *
             * ### Parameters
             * - `index`: The spend index.
             *
             * ## Events
             *
             * Emits [`Event::AssetSpendVoided`] if successful.
             **/
            voidSpend: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
            /**
             * 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 | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Call]>;
            /**
             * Send a batch of dispatch calls.
             *
             * May be called from any origin except `None`.
             *
             * - `calls`: The calls to be dispatched from the same origin. The number of call must not
             * exceed the constant: `batched_calls_limit` (available in constant metadata).
             *
             * If origin is root then the calls are dispatched without checking origin filter. (This
             * includes bypassing `frame_system::Config::BaseCallFilter`).
             *
             * ## Complexity
             * - O(C) where C is the number of calls to be batched.
             *
             * 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 | IMethod | 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 except `None`.
             *
             * - `calls`: The calls to be dispatched from the same origin. The number of call must not
             * exceed the constant: `batched_calls_limit` (available in constant metadata).
             *
             * If origin is root then the calls are dispatched without checking origin filter. (This
             * includes bypassing `frame_system::Config::BaseCallFilter`).
             *
             * ## Complexity
             * - O(C) where C is the number of calls to be batched.
             **/
            batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;
            /**
             * Dispatches a function call with a provided origin.
             *
             * The dispatch origin for this call must be _Root_.
             *
             * ## Complexity
             * - O(1).
             **/
            dispatchAs: AugmentedSubmittable<(asOrigin: FrequencyRuntimeOriginCaller | {
                system: any;
            } | {
                Council: any;
            } | {
                TechnicalCommittee: any;
            } | {
                TimeRelease: any;
            } | string | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [FrequencyRuntimeOriginCaller, Call]>;
            /**
             * Dispatches a function call with a provided origin.
             *
             * Almost the same as [`Pallet::dispatch_as`] but forwards any error of the inner call.
             *
             * The dispatch origin for this call must be _Root_.
             **/
            dispatchAsFallible: AugmentedSubmittable<(asOrigin: FrequencyRuntimeOriginCaller | {
                system: any;
            } | {
                Council: any;
            } | {
                TechnicalCommittee: any;
            } | {
                TimeRelease: any;
            } | string | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [FrequencyRuntimeOriginCaller, Call]>;
            /**
             * Send a batch of dispatch calls.
             * Unlike `batch`, it allows errors and won't interrupt.
             *
             * May be called from any origin except `None`.
             *
             * - `calls`: The calls to be dispatched from the same origin. The number of call must not
             * exceed the constant: `batched_calls_limit` (available in constant metadata).
             *
             * If origin is root then the calls are dispatch without checking origin filter. (This
             * includes bypassing `frame_system::Config::BaseCallFilter`).
             *
             * ## Complexity
             * - O(C) where C is the number of calls to be batched.
             **/
            forceBatch: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;
            /**
             * Dispatch a fallback call in the event the main call fails to execute.
             * May be called from any origin except `None`.
             *
             * This function first attempts to dispatch the `main` call.
             * If the `main` call fails, the `fallback` is attemted.
             * if the fallback is successfully dispatched, the weights of both calls
             * are accumulated and an event containing the main call error is deposited.
             *
             * In the event of a fallback failure the whole call fails
             * with the weights returned.
             *
             * - `main`: The main call to be dispatched. This is the primary action to execute.
             * - `fallback`: The fallback call to be dispatched in case the `main` call fails.
             *
             * ## Dispatch Logic
             * - If the origin is `root`, both the main and fallback calls are executed without
             * applying any origin filters.
             * - If the origin is not `root`, the origin filter is applied to both the `main` and
             * `fallback` calls.
             *
             * ## Use Case
             * - Some use cases might involve submitting a `batch` type call in either main, fallback
             * or both.
             **/
            ifElse: AugmentedSubmittable<(main: Call | IMethod | string | Uint8Array, fallback: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, Call]>;
            /**
             * Dispatch a function call with a specified weight.
             *
             * This function does not check the weight of the call, and instead allows the
             * Root origin to specify the weight of the call.
             *
             * The dispatch origin for this call must be _Root_.
             **/
            withWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | {
                refTime?: any;
                proofSize?: any;
            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;
            /**
             * Generic tx
             **/
            [key: string]: SubmittableExtrinsicFunction<ApiType>;
        };
    }
}