augment-api-tx.ts

// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
/* eslint-disable */

// import type lookup before we augment - in some environments
// this is required to allow for ambient/previous definitions
import "@polkadot/api-base/types/submittable";

import type {
  ApiTypes,
  AugmentedSubmittable,
  SubmittableExtrinsic,
  SubmittableExtrinsicFunction
} from "@polkadot/api-base/types";
import type { Bytes, Compact, Option, Vec, bool, u128, u32, u64 } 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 {
  CumulusPrimitivesCoreAggregateMessageOrigin,
  CumulusPrimitivesParachainInherentParachainInherentData,
  PalletBalancesAdjustmentDirection,
  PalletFileSystemBucketMoveRequestResponse,
  PalletFileSystemMspStorageRequestResponse,
  PalletNftsAttributeNamespace,
  PalletNftsCancelAttributesApprovalWitness,
  PalletNftsCollectionConfig,
  PalletNftsDestroyWitness,
  PalletNftsItemConfig,
  PalletNftsItemTip,
  PalletNftsMintSettings,
  PalletNftsMintWitness,
  PalletNftsPreSignedAttributes,
  PalletNftsPreSignedMint,
  PalletNftsPriceWithDirection,
  PalletProofsDealerProof,
  PalletStorageProvidersValueProposition,
  ShpFileKeyVerifierFileKeyProof,
  SpRuntimeMultiSignature,
  SpTrieStorageProofCompactProof,
  SpWeightsWeightV2Weight,
  StagingXcmExecutorAssetTransferTransferType,
  StagingXcmV4Location,
  StorageHubRuntimeConfigsRuntimeParamsRuntimeParameters,
  StorageHubRuntimeSessionKeys,
  XcmV3WeightLimit,
  XcmVersionedAssetId,
  XcmVersionedAssets,
  XcmVersionedLocation,
  XcmVersionedXcm
} 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>;
    };
    bucketNfts: {
      /**
       * Share access to files within a bucket with another account.
       *
       * The `read_access_regex` parameter is optional and when set to `None` it means that the recipient will be denied access for any read request within the bucket.
       **/
      shareAccess: AugmentedSubmittable<
        (
          recipient:
            | MultiAddress
            | { Id: any }
            | { Index: any }
            | { Raw: any }
            | { Address32: any }
            | { Address20: any }
            | string
            | Uint8Array,
          bucket: H256 | string | Uint8Array,
          itemId: u32 | AnyNumber | Uint8Array,
          readAccessRegex: Option<Bytes> | null | Uint8Array | Bytes | string
        ) => SubmittableExtrinsic<ApiType>,
        [MultiAddress, H256, u32, Option<Bytes>]
      >;
      /**
       * Update read access for an item.
       **/
      updateReadAccess: AugmentedSubmittable<
        (
          bucket: H256 | string | Uint8Array,
          itemId: u32 | AnyNumber | Uint8Array,
          readAccessRegex: Option<Bytes> | null | Uint8Array | Bytes | string
        ) => SubmittableExtrinsic<ApiType>,
        [H256, u32, Option<Bytes>]
      >;
      /**
       * 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>;
    };
    cumulusXcm: {
      /**
       * Generic tx
       **/
      [key: string]: SubmittableExtrinsicFunction<ApiType>;
    };
    fileSystem: {
      /**
       * Add yourself as a data server for providing the files of the bucket requested to be moved.
       **/
      bspAddDataServerForMoveBucketRequest: AugmentedSubmittable<
        (bucketId: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [H256]
      >;
      /**
       * Executed by a BSP to confirm to stop storing a file.
       *
       * It has to have previously opened a pending stop storing request using the `bsp_request_stop_storing` extrinsic.
       * The minimum amount of blocks between the request and the confirmation is defined by the runtime, such that the
       * BSP can't immediately stop storing a file it has previously lost when receiving a challenge for it.
       **/
      bspConfirmStopStoring: AugmentedSubmittable<
        (
          fileKey: H256 | string | Uint8Array,
          inclusionForestProof:
            | SpTrieStorageProofCompactProof
            | { encodedNodes?: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [H256, SpTrieStorageProofCompactProof]
      >;
      /**
       * Used by a BSP to confirm they are storing data of a storage request.
       **/
      bspConfirmStoring: AugmentedSubmittable<
        (
          nonInclusionForestProof:
            | SpTrieStorageProofCompactProof
            | { encodedNodes?: any }
            | string
            | Uint8Array,
          fileKeysAndProofs:
            | Vec<ITuple<[H256, ShpFileKeyVerifierFileKeyProof]>>
            | [
                H256 | string | Uint8Array,
                (
                  | ShpFileKeyVerifierFileKeyProof
                  | { fileMetadata?: any; proof?: any }
                  | string
                  | Uint8Array
                )
              ][]
        ) => SubmittableExtrinsic<ApiType>,
        [SpTrieStorageProofCompactProof, Vec<ITuple<[H256, ShpFileKeyVerifierFileKeyProof]>>]
      >;
      /**
       * Executed by a BSP to request to stop storing a file.
       *
       * In the event when a storage request no longer exists for the data the BSP no longer stores,
       * it is required that the BSP still has access to the metadata of the initial storage request.
       * If they do not, they will at least need that metadata to reconstruct the File ID and from wherever
       * the BSP gets that data is up to it. One example could be from the assigned MSP.
       * This metadata is necessary since it is needed to reconstruct the leaf node key in the storage
       * provider's Merkle Forest.
       **/
      bspRequestStopStoring: AugmentedSubmittable<
        (
          fileKey: H256 | string | Uint8Array,
          bucketId: H256 | string | Uint8Array,
          location: Bytes | string | Uint8Array,
          owner: AccountId32 | string | Uint8Array,
          fingerprint: H256 | string | Uint8Array,
          size: u64 | AnyNumber | Uint8Array,
          canServe: bool | boolean | Uint8Array,
          inclusionForestProof:
            | SpTrieStorageProofCompactProof
            | { encodedNodes?: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [H256, H256, Bytes, AccountId32, H256, u64, bool, SpTrieStorageProofCompactProof]
      >;
      /**
       * Used by a BSP to volunteer for storing a file.
       *
       * The transaction will fail if the XOR between the file ID and the BSP ID is not below the threshold,
       * so a BSP is strongly advised to check beforehand. Another reason for failure is
       * if the maximum number of BSPs has been reached. A successful assignment as BSP means
       * that some of the collateral tokens of that MSP are frozen.
       **/
      bspVolunteer: AugmentedSubmittable<
        (fileKey: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [H256]
      >;
      /**
       * Create and associate a collection with a bucket.
       **/
      createAndAssociateCollectionWithBucket: AugmentedSubmittable<
        (bucketId: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [H256]
      >;
      createBucket: AugmentedSubmittable<
        (
          mspId: H256 | string | Uint8Array,
          name: Bytes | string | Uint8Array,
          private: bool | boolean | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [H256, Bytes, bool]
      >;
      deleteFile: AugmentedSubmittable<
        (
          bucketId: H256 | string | Uint8Array,
          fileKey: H256 | string | Uint8Array,
          location: Bytes | string | Uint8Array,
          size: u64 | AnyNumber | Uint8Array,
          fingerprint: H256 | string | Uint8Array,
          maybeInclusionForestProof:
            | Option<SpTrieStorageProofCompactProof>
            | null
            | Uint8Array
            | SpTrieStorageProofCompactProof
            | { encodedNodes?: any }
            | string
        ) => SubmittableExtrinsic<ApiType>,
        [H256, H256, Bytes, u64, H256, Option<SpTrieStorageProofCompactProof>]
      >;
      /**
       * Issue a new storage request for a file
       **/
      issueStorageRequest: AugmentedSubmittable<
        (
          bucketId: H256 | string | Uint8Array,
          location: Bytes | string | Uint8Array,
          fingerprint: H256 | string | Uint8Array,
          size: u64 | AnyNumber | Uint8Array,
          mspId: H256 | string | Uint8Array,
          peerIds: Vec<Bytes> | (Bytes | string | Uint8Array)[]
        ) => SubmittableExtrinsic<ApiType>,
        [H256, Bytes, H256, u64, H256, Vec<Bytes>]
      >;
      mspRespondMoveBucketRequest: AugmentedSubmittable<
        (
          bucketId: H256 | string | Uint8Array,
          response:
            | PalletFileSystemBucketMoveRequestResponse
            | "Accepted"
            | "Rejected"
            | number
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [H256, PalletFileSystemBucketMoveRequestResponse]
      >;
      /**
       * Used by a MSP to accept or decline storage requests in batches, grouped by bucket.
       *
       * This follows a best-effort strategy, meaning that all file keys will be processed and declared to have successfully be
       * accepted, rejected or have failed to be processed in the results of the event emitted.
       *
       * The MSP has to provide a file proof for all the file keys that are being accepted and a non-inclusion proof for the file keys
       * in the bucket's Merkle Patricia Forest. The file proofs for the file keys is necessary to verify that
       * the MSP actually has the files, while the non-inclusion proof is necessary to verify that the MSP
       * wasn't storing it before.
       **/
      mspRespondStorageRequestsMultipleBuckets: AugmentedSubmittable<
        (
          fileKeyResponsesInput:
            | Vec<ITuple<[H256, PalletFileSystemMspStorageRequestResponse]>>
            | [
                H256 | string | Uint8Array,
                (
                  | PalletFileSystemMspStorageRequestResponse
                  | { accept?: any; reject?: any }
                  | string
                  | Uint8Array
                )
              ][]
        ) => SubmittableExtrinsic<ApiType>,
        [Vec<ITuple<[H256, PalletFileSystemMspStorageRequestResponse]>>]
      >;
      pendingFileDeletionRequestSubmitProof: AugmentedSubmittable<
        (
          user: AccountId32 | string | Uint8Array,
          fileKey: H256 | string | Uint8Array,
          bucketId: H256 | string | Uint8Array,
          forestProof: SpTrieStorageProofCompactProof | { encodedNodes?: any } | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [AccountId32, H256, H256, SpTrieStorageProofCompactProof]
      >;
      requestMoveBucket: AugmentedSubmittable<
        (
          bucketId: H256 | string | Uint8Array,
          newMspId: H256 | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [H256, H256]
      >;
      /**
       * Revoke storage request
       **/
      revokeStorageRequest: AugmentedSubmittable<
        (fileKey: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [H256]
      >;
      setGlobalParameters: AugmentedSubmittable<
        (
          replicationTarget: Option<u32> | null | Uint8Array | u32 | AnyNumber,
          tickRangeToMaximumThreshold: Option<u32> | null | Uint8Array | u32 | AnyNumber
        ) => SubmittableExtrinsic<ApiType>,
        [Option<u32>, Option<u32>]
      >;
      /**
       * Executed by a SP to stop storing a file from an insolvent user.
       *
       * This is used when a user has become insolvent and the SP needs to stop storing the files of that user, since
       * it won't be getting paid for it anymore.
       * The validations are similar to the ones in the `bsp_request_stop_storing` and `bsp_confirm_stop_storing` extrinsics, but the SP doesn't need to
       * wait for a minimum amount of blocks to confirm to stop storing the file nor it has to be a BSP.
       **/
      stopStoringForInsolventUser: AugmentedSubmittable<
        (
          fileKey: H256 | string | Uint8Array,
          bucketId: H256 | string | Uint8Array,
          location: Bytes | string | Uint8Array,
          owner: AccountId32 | string | Uint8Array,
          fingerprint: H256 | string | Uint8Array,
          size: u64 | AnyNumber | Uint8Array,
          inclusionForestProof:
            | SpTrieStorageProofCompactProof
            | { encodedNodes?: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [H256, H256, Bytes, AccountId32, H256, u64, SpTrieStorageProofCompactProof]
      >;
      updateBucketPrivacy: AugmentedSubmittable<
        (
          bucketId: H256 | string | Uint8Array,
          private: bool | boolean | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [H256, bool]
      >;
      /**
       * Generic tx
       **/
      [key: string]: SubmittableExtrinsicFunction<ApiType>;
    };
    messageQueue: {
      /**
       * Execute an overweight message.
       *
       * Temporary processing errors will be propagated whereas permanent errors are treated
       * as success condition.
       *
       * - `origin`: Must be `Signed`.
       * - `message_origin`: The origin from which the message to be executed arrived.
       * - `page`: The page in the queue in which the message to be executed is sitting.
       * - `index`: The index into the queue of the message to be executed.
       * - `weight_limit`: The maximum amount of weight allowed to be consumed in the execution
       * of the message.
       *
       * Benchmark complexity considerations: O(index + weight_limit).
       **/
      executeOverweight: AugmentedSubmittable<
        (
          messageOrigin:
            | CumulusPrimitivesCoreAggregateMessageOrigin
            | { Here: any }
            | { Parent: any }
            | { Sibling: any }
            | string
            | Uint8Array,
          page: u32 | AnyNumber | Uint8Array,
          index: u32 | AnyNumber | Uint8Array,
          weightLimit:
            | SpWeightsWeightV2Weight
            | { refTime?: any; proofSize?: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [CumulusPrimitivesCoreAggregateMessageOrigin, u32, u32, SpWeightsWeightV2Weight]
      >;
      /**
       * Remove a page which has no more messages remaining to be processed or is stale.
       **/
      reapPage: AugmentedSubmittable<
        (
          messageOrigin:
            | CumulusPrimitivesCoreAggregateMessageOrigin
            | { Here: any }
            | { Parent: any }
            | { Sibling: any }
            | string
            | Uint8Array,
          pageIndex: u32 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [CumulusPrimitivesCoreAggregateMessageOrigin, u32]
      >;
      /**
       * Generic tx
       **/
      [key: string]: SubmittableExtrinsicFunction<ApiType>;
    };
    nfts: {
      /**
       * Approve item's attributes to be changed by a delegated third-party account.
       *
       * Origin must be Signed and must be an owner of the `item`.
       *
       * - `collection`: A collection of the item.
       * - `item`: The item that holds attributes.
       * - `delegate`: The account to delegate permission to change attributes of the item.
       *
       * Emits `ItemAttributesApprovalAdded` on success.
       **/
      approveItemAttributes: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          item: u32 | AnyNumber | Uint8Array,
          delegate:
            | MultiAddress
            | { Id: any }
            | { Index: any }
            | { Raw: any }
            | { Address32: any }
            | { Address20: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32, MultiAddress]
      >;
      /**
       * Approve an item to be transferred by a delegated third-party account.
       *
       * Origin must be either `ForceOrigin` or Signed and the sender should be the Owner of the
       * `item`.
       *
       * - `collection`: The collection of the item to be approved for delegated transfer.
       * - `item`: The item to be approved for delegated transfer.
       * - `delegate`: The account to delegate permission to transfer the item.
       * - `maybe_deadline`: Optional deadline for the approval. Specified by providing the
       * number of blocks after which the approval will expire
       *
       * Emits `TransferApproved` on success.
       *
       * Weight: `O(1)`
       **/
      approveTransfer: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          item: u32 | AnyNumber | Uint8Array,
          delegate:
            | MultiAddress
            | { Id: any }
            | { Index: any }
            | { Raw: any }
            | { Address32: any }
            | { Address20: any }
            | string
            | Uint8Array,
          maybeDeadline: Option<u32> | null | Uint8Array | u32 | AnyNumber
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32, MultiAddress, Option<u32>]
      >;
      /**
       * Destroy a single item.
       *
       * The origin must conform to `ForceOrigin` or must be Signed and the signing account must
       * be the owner of the `item`.
       *
       * - `collection`: The collection of the item to be burned.
       * - `item`: The item to be burned.
       *
       * Emits `Burned`.
       *
       * Weight: `O(1)`
       **/
      burn: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          item: u32 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32]
      >;
      /**
       * Allows to buy an item if it's up for sale.
       *
       * Origin must be Signed and must not be the owner of the `item`.
       *
       * - `collection`: The collection of the item.
       * - `item`: The item the sender wants to buy.
       * - `bid_price`: The price the sender is willing to pay.
       *
       * Emits `ItemBought` on success.
       **/
      buyItem: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          item: u32 | AnyNumber | Uint8Array,
          bidPrice: u128 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32, u128]
      >;
      /**
       * Cancel one of the transfer approvals for a specific item.
       *
       * Origin must be either:
       * - the `Force` origin;
       * - `Signed` with the signer being the Owner of the `item`;
       *
       * Arguments:
       * - `collection`: The collection of the item of whose approval will be cancelled.
       * - `item`: The item of the collection of whose approval will be cancelled.
       * - `delegate`: The account that is going to loose their approval.
       *
       * Emits `ApprovalCancelled` on success.
       *
       * Weight: `O(1)`
       **/
      cancelApproval: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          item: u32 | AnyNumber | Uint8Array,
          delegate:
            | MultiAddress
            | { Id: any }
            | { Index: any }
            | { Raw: any }
            | { Address32: any }
            | { Address20: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32, MultiAddress]
      >;
      /**
       * Cancel the previously provided approval to change item's attributes.
       * All the previously set attributes by the `delegate` will be removed.
       *
       * Origin must be Signed and must be an owner of the `item`.
       *
       * - `collection`: Collection that the item is contained within.
       * - `item`: The item that holds attributes.
       * - `delegate`: The previously approved account to remove.
       *
       * Emits `ItemAttributesApprovalRemoved` on success.
       **/
      cancelItemAttributesApproval: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          item: u32 | AnyNumber | Uint8Array,
          delegate:
            | MultiAddress
            | { Id: any }
            | { Index: any }
            | { Raw: any }
            | { Address32: any }
            | { Address20: any }
            | string
            | Uint8Array,
          witness:
            | PalletNftsCancelAttributesApprovalWitness
            | { accountAttributes?: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32, MultiAddress, PalletNftsCancelAttributesApprovalWitness]
      >;
      /**
       * Cancel an atomic swap.
       *
       * Origin must be Signed.
       * Origin must be an owner of the `item` if the deadline hasn't expired.
       *
       * - `collection`: The collection of the item.
       * - `item`: The item an owner wants to give.
       *
       * Emits `SwapCancelled` on success.
       **/
      cancelSwap: AugmentedSubmittable<
        (
          offeredCollection: u32 | AnyNumber | Uint8Array,
          offeredItem: u32 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32]
      >;
      /**
       * Claim an atomic swap.
       * This method executes a pending swap, that was created by a counterpart before.
       *
       * Origin must be Signed and must be an owner of the `item`.
       *
       * - `send_collection`: The collection of the item to be sent.
       * - `send_item`: The item to be sent.
       * - `receive_collection`: The collection of the item to be received.
       * - `receive_item`: The item to be received.
       * - `witness_price`: A price that was previously agreed on.
       *
       * Emits `SwapClaimed` on success.
       **/
      claimSwap: AugmentedSubmittable<
        (
          sendCollection: u32 | AnyNumber | Uint8Array,
          sendItem: u32 | AnyNumber | Uint8Array,
          receiveCollection: u32 | AnyNumber | Uint8Array,
          receiveItem: u32 | AnyNumber | Uint8Array,
          witnessPrice:
            | Option<PalletNftsPriceWithDirection>
            | null
            | Uint8Array
            | PalletNftsPriceWithDirection
            | { amount?: any; direction?: any }
            | string
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32, u32, u32, Option<PalletNftsPriceWithDirection>]
      >;
      /**
       * Cancel all the approvals of a specific item.
       *
       * Origin must be either:
       * - the `Force` origin;
       * - `Signed` with the signer being the Owner of the `item`;
       *
       * Arguments:
       * - `collection`: The collection of the item of whose approvals will be cleared.
       * - `item`: The item of the collection of whose approvals will be cleared.
       *
       * Emits `AllApprovalsCancelled` on success.
       *
       * Weight: `O(1)`
       **/
      clearAllTransferApprovals: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          item: u32 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32]
      >;
      /**
       * Clear an attribute for a collection or item.
       *
       * Origin must be either `ForceOrigin` or Signed and the sender should be the Owner of the
       * attribute.
       *
       * Any deposit is freed for the collection's owner.
       *
       * - `collection`: The identifier of the collection whose item's metadata to clear.
       * - `maybe_item`: The identifier of the item whose metadata to clear.
       * - `namespace`: Attribute's namespace.
       * - `key`: The key of the attribute.
       *
       * Emits `AttributeCleared`.
       *
       * Weight: `O(1)`
       **/
      clearAttribute: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          maybeItem: Option<u32> | null | Uint8Array | u32 | AnyNumber,
          namespace:
            | PalletNftsAttributeNamespace
            | { Pallet: any }
            | { CollectionOwner: any }
            | { ItemOwner: any }
            | { Account: any }
            | string
            | Uint8Array,
          key: Bytes | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, Option<u32>, PalletNftsAttributeNamespace, Bytes]
      >;
      /**
       * Clear the metadata for a collection.
       *
       * Origin must be either `ForceOrigin` or `Signed` and the sender should be the Admin of
       * the `collection`.
       *
       * Any deposit is freed for the collection's owner.
       *
       * - `collection`: The identifier of the collection whose metadata to clear.
       *
       * Emits `CollectionMetadataCleared`.
       *
       * Weight: `O(1)`
       **/
      clearCollectionMetadata: AugmentedSubmittable<
        (collection: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [u32]
      >;
      /**
       * Clear the metadata for an item.
       *
       * Origin must be either `ForceOrigin` or Signed and the sender should be the Admin of the
       * `collection`.
       *
       * Any deposit is freed for the collection's owner.
       *
       * - `collection`: The identifier of the collection whose item's metadata to clear.
       * - `item`: The identifier of the item whose metadata to clear.
       *
       * Emits `ItemMetadataCleared`.
       *
       * Weight: `O(1)`
       **/
      clearMetadata: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          item: u32 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32]
      >;
      /**
       * Issue a new collection of non-fungible items from a public origin.
       *
       * This new collection has no items initially and its owner is the origin.
       *
       * The origin must be Signed and the sender must have sufficient funds free.
       *
       * `CollectionDeposit` funds of sender are reserved.
       *
       * Parameters:
       * - `admin`: The admin of this collection. The admin is the initial address of each
       * member of the collection's admin team.
       *
       * Emits `Created` event when successful.
       *
       * Weight: `O(1)`
       **/
      create: AugmentedSubmittable<
        (
          admin:
            | MultiAddress
            | { Id: any }
            | { Index: any }
            | { Raw: any }
            | { Address32: any }
            | { Address20: any }
            | string
            | Uint8Array,
          config:
            | PalletNftsCollectionConfig
            | { settings?: any; maxSupply?: any; mintSettings?: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [MultiAddress, PalletNftsCollectionConfig]
      >;
      /**
       * Register a new atomic swap, declaring an intention to send an `item` in exchange for
       * `desired_item` from origin to target on the current blockchain.
       * The target can execute the swap during the specified `duration` of blocks (if set).
       * Additionally, the price could be set for the desired `item`.
       *
       * Origin must be Signed and must be an owner of the `item`.
       *
       * - `collection`: The collection of the item.
       * - `item`: The item an owner wants to give.
       * - `desired_collection`: The collection of the desired item.
       * - `desired_item`: The desired item an owner wants to receive.
       * - `maybe_price`: The price an owner is willing to pay or receive for the desired `item`.
       * - `duration`: A deadline for the swap. Specified by providing the number of blocks
       * after which the swap will expire.
       *
       * Emits `SwapCreated` on success.
       **/
      createSwap: AugmentedSubmittable<
        (
          offeredCollection: u32 | AnyNumber | Uint8Array,
          offeredItem: u32 | AnyNumber | Uint8Array,
          desiredCollection: u32 | AnyNumber | Uint8Array,
          maybeDesiredItem: Option<u32> | null | Uint8Array | u32 | AnyNumber,
          maybePrice:
            | Option<PalletNftsPriceWithDirection>
            | null
            | Uint8Array
            | PalletNftsPriceWithDirection
            | { amount?: any; direction?: any }
            | string,
          duration: u32 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32, u32, Option<u32>, Option<PalletNftsPriceWithDirection>, u32]
      >;
      /**
       * Destroy a collection of fungible items.
       *
       * The origin must conform to `ForceOrigin` or must be `Signed` and the sender must be the
       * owner of the `collection`.
       *
       * NOTE: The collection must have 0 items to be destroyed.
       *
       * - `collection`: The identifier of the collection to be destroyed.
       * - `witness`: Information on the items minted in the collection. This must be
       * correct.
       *
       * Emits `Destroyed` event when successful.
       *
       * Weight: `O(m + c + a)` where:
       * - `m = witness.item_metadatas`
       * - `c = witness.item_configs`
       * - `a = witness.attributes`
       **/
      destroy: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          witness:
            | PalletNftsDestroyWitness
            | { itemMetadatas?: any; itemConfigs?: any; attributes?: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, PalletNftsDestroyWitness]
      >;
      /**
       * Change the config of a collection.
       *
       * Origin must be `ForceOrigin`.
       *
       * - `collection`: The identifier of the collection.
       * - `config`: The new config of this collection.
       *
       * Emits `CollectionConfigChanged`.
       *
       * Weight: `O(1)`
       **/
      forceCollectionConfig: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          config:
            | PalletNftsCollectionConfig
            | { settings?: any; maxSupply?: any; mintSettings?: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, PalletNftsCollectionConfig]
      >;
      /**
       * Change the Owner of a collection.
       *
       * Origin must be `ForceOrigin`.
       *
       * - `collection`: The identifier of the collection.
       * - `owner`: The new Owner of this collection.
       *
       * Emits `OwnerChanged`.
       *
       * Weight: `O(1)`
       **/
      forceCollectionOwner: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          owner:
            | MultiAddress
            | { Id: any }
            | { Index: any }
            | { Raw: any }
            | { Address32: any }
            | { Address20: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, MultiAddress]
      >;
      /**
       * Issue a new collection of non-fungible items from a privileged origin.
       *
       * This new collection has no items initially.
       *
       * The origin must conform to `ForceOrigin`.
       *
       * Unlike `create`, no funds are reserved.
       *
       * - `owner`: The owner of this collection of items. The owner has full superuser
       * permissions over this item, but may later change and configure the permissions using
       * `transfer_ownership` and `set_team`.
       *
       * Emits `ForceCreated` event when successful.
       *
       * Weight: `O(1)`
       **/
      forceCreate: AugmentedSubmittable<
        (
          owner:
            | MultiAddress
            | { Id: any }
            | { Index: any }
            | { Raw: any }
            | { Address32: any }
            | { Address20: any }
            | string
            | Uint8Array,
          config:
            | PalletNftsCollectionConfig
            | { settings?: any; maxSupply?: any; mintSettings?: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [MultiAddress, PalletNftsCollectionConfig]
      >;
      /**
       * Mint an item of a particular collection from a privileged origin.
       *
       * The origin must conform to `ForceOrigin` or must be `Signed` and the sender must be the
       * Issuer of the `collection`.
       *
       * - `collection`: The collection of the item to be minted.
       * - `item`: An identifier of the new item.
       * - `mint_to`: Account into which the item will be minted.
       * - `item_config`: A config of the new item.
       *
       * Emits `Issued` event when successful.
       *
       * Weight: `O(1)`
       **/
      forceMint: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          item: u32 | AnyNumber | Uint8Array,
          mintTo:
            | MultiAddress
            | { Id: any }
            | { Index: any }
            | { Raw: any }
            | { Address32: any }
            | { Address20: any }
            | string
            | Uint8Array,
          itemConfig: PalletNftsItemConfig | { settings?: any } | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32, MultiAddress, PalletNftsItemConfig]
      >;
      /**
       * Force-set an attribute for a collection or item.
       *
       * Origin must be `ForceOrigin`.
       *
       * If the attribute already exists and it was set by another account, the deposit
       * will be returned to the previous owner.
       *
       * - `set_as`: An optional owner of the attribute.
       * - `collection`: The identifier of the collection whose item's metadata to set.
       * - `maybe_item`: The identifier of the item whose metadata to set.
       * - `namespace`: Attribute's namespace.
       * - `key`: The key of the attribute.
       * - `value`: The value to which to set the attribute.
       *
       * Emits `AttributeSet`.
       *
       * Weight: `O(1)`
       **/
      forceSetAttribute: AugmentedSubmittable<
        (
          setAs: Option<AccountId32> | null | Uint8Array | AccountId32 | string,
          collection: u32 | AnyNumber | Uint8Array,
          maybeItem: Option<u32> | null | Uint8Array | u32 | AnyNumber,
          namespace:
            | PalletNftsAttributeNamespace
            | { Pallet: any }
            | { CollectionOwner: any }
            | { ItemOwner: any }
            | { Account: any }
            | string
            | Uint8Array,
          key: Bytes | string | Uint8Array,
          value: Bytes | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [Option<AccountId32>, u32, Option<u32>, PalletNftsAttributeNamespace, Bytes, Bytes]
      >;
      /**
       * Disallows specified settings for the whole collection.
       *
       * Origin must be Signed and the sender should be the Owner of the `collection`.
       *
       * - `collection`: The collection to be locked.
       * - `lock_settings`: The settings to be locked.
       *
       * Note: it's possible to only lock(set) the setting, but not to unset it.
       *
       * Emits `CollectionLocked`.
       *
       * Weight: `O(1)`
       **/
      lockCollection: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          lockSettings: u64 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u64]
      >;
      /**
       * Disallows changing the metadata or attributes of the item.
       *
       * Origin must be either `ForceOrigin` or Signed and the sender should be the Admin
       * of the `collection`.
       *
       * - `collection`: The collection if the `item`.
       * - `item`: An item to be locked.
       * - `lock_metadata`: Specifies whether the metadata should be locked.
       * - `lock_attributes`: Specifies whether the attributes in the `CollectionOwner` namespace
       * should be locked.
       *
       * Note: `lock_attributes` affects the attributes in the `CollectionOwner` namespace only.
       * When the metadata or attributes are locked, it won't be possible the unlock them.
       *
       * Emits `ItemPropertiesLocked`.
       *
       * Weight: `O(1)`
       **/
      lockItemProperties: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          item: u32 | AnyNumber | Uint8Array,
          lockMetadata: bool | boolean | Uint8Array,
          lockAttributes: bool | boolean | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32, bool, bool]
      >;
      /**
       * Disallow further unprivileged transfer of an item.
       *
       * Origin must be Signed and the sender should be the Freezer of the `collection`.
       *
       * - `collection`: The collection of the item to be changed.
       * - `item`: The item to become non-transferable.
       *
       * Emits `ItemTransferLocked`.
       *
       * Weight: `O(1)`
       **/
      lockItemTransfer: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          item: u32 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32]
      >;
      /**
       * Mint an item of a particular collection.
       *
       * The origin must be Signed and the sender must comply with the `mint_settings` rules.
       *
       * - `collection`: The collection of the item to be minted.
       * - `item`: An identifier of the new item.
       * - `mint_to`: Account into which the item will be minted.
       * - `witness_data`: When the mint type is `HolderOf(collection_id)`, then the owned
       * item_id from that collection needs to be provided within the witness data object. If
       * the mint price is set, then it should be additionally confirmed in the `witness_data`.
       *
       * Note: the deposit will be taken from the `origin` and not the `owner` of the `item`.
       *
       * Emits `Issued` event when successful.
       *
       * Weight: `O(1)`
       **/
      mint: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          item: u32 | AnyNumber | Uint8Array,
          mintTo:
            | MultiAddress
            | { Id: any }
            | { Index: any }
            | { Raw: any }
            | { Address32: any }
            | { Address20: any }
            | string
            | Uint8Array,
          witnessData:
            | Option<PalletNftsMintWitness>
            | null
            | Uint8Array
            | PalletNftsMintWitness
            | { ownedItem?: any; mintPrice?: any }
            | string
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32, MultiAddress, Option<PalletNftsMintWitness>]
      >;
      /**
       * Mint an item by providing the pre-signed approval.
       *
       * Origin must be Signed.
       *
       * - `mint_data`: The pre-signed approval that consists of the information about the item,
       * its metadata, attributes, who can mint it (`None` for anyone) and until what block
       * number.
       * - `signature`: The signature of the `data` object.
       * - `signer`: The `data` object's signer. Should be an Issuer of the collection.
       *
       * Emits `Issued` on success.
       * Emits `AttributeSet` if the attributes were provided.
       * Emits `ItemMetadataSet` if the metadata was not empty.
       **/
      mintPreSigned: AugmentedSubmittable<
        (
          mintData:
            | PalletNftsPreSignedMint
            | {
                collection?: any;
                item?: any;
                attributes?: any;
                metadata?: any;
                onlyAccount?: any;
                deadline?: any;
                mintPrice?: any;
              }
            | string
            | Uint8Array,
          signature:
            | SpRuntimeMultiSignature
            | { Ed25519: any }
            | { Sr25519: any }
            | { Ecdsa: any }
            | string
            | Uint8Array,
          signer: AccountId32 | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [PalletNftsPreSignedMint, SpRuntimeMultiSignature, AccountId32]
      >;
      /**
       * Allows to pay the tips.
       *
       * Origin must be Signed.
       *
       * - `tips`: Tips array.
       *
       * Emits `TipSent` on every tip transfer.
       **/
      payTips: AugmentedSubmittable<
        (
          tips:
            | Vec<PalletNftsItemTip>
            | (
                | PalletNftsItemTip
                | { collection?: any; item?: any; receiver?: any; amount?: any }
                | string
                | Uint8Array
              )[]
        ) => SubmittableExtrinsic<ApiType>,
        [Vec<PalletNftsItemTip>]
      >;
      /**
       * Re-evaluate the deposits on some items.
       *
       * Origin must be Signed and the sender should be the Owner of the `collection`.
       *
       * - `collection`: The collection of the items to be reevaluated.
       * - `items`: The items of the collection whose deposits will be reevaluated.
       *
       * NOTE: This exists as a best-effort function. Any items which are unknown or
       * in the case that the owner account does not have reservable funds to pay for a
       * deposit increase are ignored. Generally the owner isn't going to call this on items
       * whose existing deposit is less than the refreshed deposit as it would only cost them,
       * so it's of little consequence.
       *
       * It will still return an error in the case that the collection is unknown or the signer
       * is not permitted to call it.
       *
       * Weight: `O(items.len())`
       **/
      redeposit: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          items: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]
        ) => SubmittableExtrinsic<ApiType>,
        [u32, Vec<u32>]
      >;
      /**
       * Set (or reset) the acceptance of ownership for a particular account.
       *
       * Origin must be `Signed` and if `maybe_collection` is `Some`, then the signer must have a
       * provider reference.
       *
       * - `maybe_collection`: The identifier of the collection whose ownership the signer is
       * willing to accept, or if `None`, an indication that the signer is willing to accept no
       * ownership transferal.
       *
       * Emits `OwnershipAcceptanceChanged`.
       **/
      setAcceptOwnership: AugmentedSubmittable<
        (
          maybeCollection: Option<u32> | null | Uint8Array | u32 | AnyNumber
        ) => SubmittableExtrinsic<ApiType>,
        [Option<u32>]
      >;
      /**
       * Set an attribute for a collection or item.
       *
       * Origin must be Signed and must conform to the namespace ruleset:
       * - `CollectionOwner` namespace could be modified by the `collection` Admin only;
       * - `ItemOwner` namespace could be modified by the `maybe_item` owner only. `maybe_item`
       * should be set in that case;
       * - `Account(AccountId)` namespace could be modified only when the `origin` was given a
       * permission to do so;
       *
       * The funds of `origin` are reserved according to the formula:
       * `AttributeDepositBase + DepositPerByte * (key.len + value.len)` taking into
       * account any already reserved funds.
       *
       * - `collection`: The identifier of the collection whose item's metadata to set.
       * - `maybe_item`: The identifier of the item whose metadata to set.
       * - `namespace`: Attribute's namespace.
       * - `key`: The key of the attribute.
       * - `value`: The value to which to set the attribute.
       *
       * Emits `AttributeSet`.
       *
       * Weight: `O(1)`
       **/
      setAttribute: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          maybeItem: Option<u32> | null | Uint8Array | u32 | AnyNumber,
          namespace:
            | PalletNftsAttributeNamespace
            | { Pallet: any }
            | { CollectionOwner: any }
            | { ItemOwner: any }
            | { Account: any }
            | string
            | Uint8Array,
          key: Bytes | string | Uint8Array,
          value: Bytes | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, Option<u32>, PalletNftsAttributeNamespace, Bytes, Bytes]
      >;
      /**
       * Set attributes for an item by providing the pre-signed approval.
       *
       * Origin must be Signed and must be an owner of the `data.item`.
       *
       * - `data`: The pre-signed approval that consists of the information about the item,
       * attributes to update and until what block number.
       * - `signature`: The signature of the `data` object.
       * - `signer`: The `data` object's signer. Should be an Admin of the collection for the
       * `CollectionOwner` namespace.
       *
       * Emits `AttributeSet` for each provided attribute.
       * Emits `ItemAttributesApprovalAdded` if the approval wasn't set before.
       * Emits `PreSignedAttributesSet` on success.
       **/
      setAttributesPreSigned: AugmentedSubmittable<
        (
          data:
            | PalletNftsPreSignedAttributes
            | { collection?: any; item?: any; attributes?: any; namespace?: any; deadline?: any }
            | string
            | Uint8Array,
          signature:
            | SpRuntimeMultiSignature
            | { Ed25519: any }
            | { Sr25519: any }
            | { Ecdsa: any }
            | string
            | Uint8Array,
          signer: AccountId32 | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [PalletNftsPreSignedAttributes, SpRuntimeMultiSignature, AccountId32]
      >;
      /**
       * Set the maximum number of items a collection could have.
       *
       * Origin must be either `ForceOrigin` or `Signed` and the sender should be the Owner of
       * the `collection`.
       *
       * - `collection`: The identifier of the collection to change.
       * - `max_supply`: The maximum number of items a collection could have.
       *
       * Emits `CollectionMaxSupplySet` event when successful.
       **/
      setCollectionMaxSupply: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          maxSupply: u32 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32]
      >;
      /**
       * Set the metadata for a collection.
       *
       * Origin must be either `ForceOrigin` or `Signed` and the sender should be the Admin of
       * the `collection`.
       *
       * If the origin is `Signed`, then funds of signer are reserved according to the formula:
       * `MetadataDepositBase + DepositPerByte * data.len` taking into
       * account any already reserved funds.
       *
       * - `collection`: The identifier of the item whose metadata to update.
       * - `data`: The general information of this item. Limited in length by `StringLimit`.
       *
       * Emits `CollectionMetadataSet`.
       *
       * Weight: `O(1)`
       **/
      setCollectionMetadata: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          data: Bytes | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, Bytes]
      >;
      /**
       * Set the metadata for an item.
       *
       * Origin must be either `ForceOrigin` or Signed and the sender should be the Admin of the
       * `collection`.
       *
       * If the origin is Signed, then funds of signer are reserved according to the formula:
       * `MetadataDepositBase + DepositPerByte * data.len` taking into
       * account any already reserved funds.
       *
       * - `collection`: The identifier of the collection whose item's metadata to set.
       * - `item`: The identifier of the item whose metadata to set.
       * - `data`: The general information of this item. Limited in length by `StringLimit`.
       *
       * Emits `ItemMetadataSet`.
       *
       * Weight: `O(1)`
       **/
      setMetadata: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          item: u32 | AnyNumber | Uint8Array,
          data: Bytes | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32, Bytes]
      >;
      /**
       * Set (or reset) the price for an item.
       *
       * Origin must be Signed and must be the owner of the `item`.
       *
       * - `collection`: The collection of the item.
       * - `item`: The item to set the price for.
       * - `price`: The price for the item. Pass `None`, to reset the price.
       * - `buyer`: Restricts the buy operation to a specific account.
       *
       * Emits `ItemPriceSet` on success if the price is not `None`.
       * Emits `ItemPriceRemoved` on success if the price is `None`.
       **/
      setPrice: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          item: u32 | AnyNumber | Uint8Array,
          price: Option<u128> | null | Uint8Array | u128 | AnyNumber,
          whitelistedBuyer:
            | Option<MultiAddress>
            | null
            | Uint8Array
            | MultiAddress
            | { Id: any }
            | { Index: any }
            | { Raw: any }
            | { Address32: any }
            | { Address20: any }
            | string
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32, Option<u128>, Option<MultiAddress>]
      >;
      /**
       * Change the Issuer, Admin and Freezer of a collection.
       *
       * Origin must be either `ForceOrigin` or Signed and the sender should be the Owner of the
       * `collection`.
       *
       * Note: by setting the role to `None` only the `ForceOrigin` will be able to change it
       * after to `Some(account)`.
       *
       * - `collection`: The collection whose team should be changed.
       * - `issuer`: The new Issuer of this collection.
       * - `admin`: The new Admin of this collection.
       * - `freezer`: The new Freezer of this collection.
       *
       * Emits `TeamChanged`.
       *
       * Weight: `O(1)`
       **/
      setTeam: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          issuer:
            | Option<MultiAddress>
            | null
            | Uint8Array
            | MultiAddress
            | { Id: any }
            | { Index: any }
            | { Raw: any }
            | { Address32: any }
            | { Address20: any }
            | string,
          admin:
            | Option<MultiAddress>
            | null
            | Uint8Array
            | MultiAddress
            | { Id: any }
            | { Index: any }
            | { Raw: any }
            | { Address32: any }
            | { Address20: any }
            | string,
          freezer:
            | Option<MultiAddress>
            | null
            | Uint8Array
            | MultiAddress
            | { Id: any }
            | { Index: any }
            | { Raw: any }
            | { Address32: any }
            | { Address20: any }
            | string
        ) => SubmittableExtrinsic<ApiType>,
        [u32, Option<MultiAddress>, Option<MultiAddress>, Option<MultiAddress>]
      >;
      /**
       * Move an item from the sender account to another.
       *
       * Origin must be Signed and the signing account must be either:
       * - the Owner of the `item`;
       * - the approved delegate for the `item` (in this case, the approval is reset).
       *
       * Arguments:
       * - `collection`: The collection of the item to be transferred.
       * - `item`: The item to be transferred.
       * - `dest`: The account to receive ownership of the item.
       *
       * Emits `Transferred`.
       *
       * Weight: `O(1)`
       **/
      transfer: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          item: u32 | AnyNumber | Uint8Array,
          dest:
            | MultiAddress
            | { Id: any }
            | { Index: any }
            | { Raw: any }
            | { Address32: any }
            | { Address20: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32, MultiAddress]
      >;
      /**
       * Change the Owner of a collection.
       *
       * Origin must be Signed and the sender should be the Owner of the `collection`.
       *
       * - `collection`: The collection whose owner should be changed.
       * - `owner`: The new Owner of this collection. They must have called
       * `set_accept_ownership` with `collection` in order for this operation to succeed.
       *
       * Emits `OwnerChanged`.
       *
       * Weight: `O(1)`
       **/
      transferOwnership: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          newOwner:
            | MultiAddress
            | { Id: any }
            | { Index: any }
            | { Raw: any }
            | { Address32: any }
            | { Address20: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, MultiAddress]
      >;
      /**
       * Re-allow unprivileged transfer of an item.
       *
       * Origin must be Signed and the sender should be the Freezer of the `collection`.
       *
       * - `collection`: The collection of the item to be changed.
       * - `item`: The item to become transferable.
       *
       * Emits `ItemTransferUnlocked`.
       *
       * Weight: `O(1)`
       **/
      unlockItemTransfer: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          item: u32 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, u32]
      >;
      /**
       * Update mint settings.
       *
       * Origin must be either `ForceOrigin` or `Signed` and the sender should be the Issuer
       * of the `collection`.
       *
       * - `collection`: The identifier of the collection to change.
       * - `mint_settings`: The new mint settings.
       *
       * Emits `CollectionMintSettingsUpdated` event when successful.
       **/
      updateMintSettings: AugmentedSubmittable<
        (
          collection: u32 | AnyNumber | Uint8Array,
          mintSettings:
            | PalletNftsMintSettings
            | {
                mintType?: any;
                price?: any;
                startBlock?: any;
                endBlock?: any;
                defaultItemSettings?: any;
              }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u32, PalletNftsMintSettings]
      >;
      /**
       * Generic tx
       **/
      [key: string]: SubmittableExtrinsicFunction<ApiType>;
    };
    parachainInfo: {
      /**
       * Generic tx
       **/
      [key: string]: SubmittableExtrinsicFunction<ApiType>;
    };
    parachainSystem: {
      /**
       * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied
       * later.
       *
       * The `check_version` parameter sets a boolean flag for whether or not the runtime's spec
       * version and name should be verified on upgrade. Since the authorization only has a hash,
       * it cannot actually perform the verification.
       *
       * This call requires Root origin.
       **/
      authorizeUpgrade: AugmentedSubmittable<
        (
          codeHash: H256 | string | Uint8Array,
          checkVersion: bool | boolean | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [H256, bool]
      >;
      /**
       * 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.
       *
       * Note that this function will not apply the new `code`, but only attempt to schedule the
       * upgrade with the Relay Chain.
       *
       * All origins are allowed.
       **/
      enactAuthorizedUpgrade: AugmentedSubmittable<
        (code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [Bytes]
      >;
      /**
       * 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;
              }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [CumulusPrimitivesParachainInherentParachainInherentData]
      >;
      sudoSendUpwardMessage: AugmentedSubmittable<
        (message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [Bytes]
      >;
      /**
       * Generic tx
       **/
      [key: string]: SubmittableExtrinsicFunction<ApiType>;
    };
    parameters: {
      /**
       * Set the value of a parameter.
       *
       * The dispatch origin of this call must be `AdminOrigin` for the given `key`. Values be
       * deleted by setting them to `None`.
       **/
      setParameter: AugmentedSubmittable<
        (
          keyValue:
            | StorageHubRuntimeConfigsRuntimeParamsRuntimeParameters
            | { RuntimeConfig: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [StorageHubRuntimeConfigsRuntimeParamsRuntimeParameters]
      >;
      /**
       * Generic tx
       **/
      [key: string]: SubmittableExtrinsicFunction<ApiType>;
    };
    paymentStreams: {
      /**
       * Dispatchable extrinsic that allows Providers to charge a payment stream from a User.
       *
       * The dispatch origin for this call must be Signed.
       * The origin must be the Provider that has at least one type of payment stream with the User.
       *
       * Parameters:
       * - `user_account`: The User Account ID that the payment stream is for.
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was signed and get the signer.
       * 2. Check that a payment stream between the signer (Provider) and the User exists
       * 3. If there is a fixed-rate payment stream:
       * 1. Get the rate of the payment stream
       * 2. Get the difference between the last charged tick number and the last chargeable tick number of the stream
       * 3. Calculate the amount to charge doing `rate * difference`
       * 4. Charge the user (if the user does not have enough funds, it gets flagged and a `UserWithoutFunds` event is emitted)
       * 5. Update the last charged tick number of the payment stream
       * 4. If there is a dynamic-rate payment stream:
       * 1. Get the amount provided by the Provider
       * 2. Get the difference between price index when the stream was last charged and the price index at the last chargeable tick
       * 3. Calculate the amount to charge doing `amount_provided * difference`
       * 4. Charge the user (if the user does not have enough funds, it gets flagged and a `UserWithoutFunds` event is emitted)
       * 5. Update the price index when the stream was last charged of the payment stream
       *
       * Emits a `PaymentStreamCharged` event when successful.
       *
       * Notes: a Provider could have both a fixed-rate and a dynamic-rate payment stream with a User. If that's the case, this extrinsic
       * will try to charge both and the amount charged will be the sum of the amounts charged for each payment stream.
       **/
      chargePaymentStreams: AugmentedSubmittable<
        (userAccount: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [AccountId32]
      >;
      /**
       * Dispatchable extrinsic that allows a user flagged as without funds long ago enough to clear this flag from its account,
       * allowing it to begin contracting and paying for services again. If there's any outstanding debt, it will be charged and cleared.
       *
       * The dispatch origin for this call must be Signed.
       * The origin must be the User that has been flagged as without funds.
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was signed and get the signer.
       * 2. Check that the user has been flagged as without funds.
       * 3. Check that the cooldown period has passed since the user was flagged as without funds.
       * 4. Check if there's any outstanding debt and charge it. This is done by:
       * a. Releasing any remaining funds held as a deposit for each payment stream.
       * b. Getting all payment streams of the user and charging them, paying the Providers for the services.
       * c. Returning the User any remaining funds.
       * d. Deleting all payment streams of the user.
       * 5. Unflag the user as without funds.
       *
       * Emits a 'UserSolvent' event when successful.
       *
       * Notes: this extrinsic iterates over all remaining payment streams of the user and charges them, so it can be expensive in terms of weight.
       * The fee to execute it should be high enough to compensate for the weight of the extrinsic, without being too high that the user
       * finds more convenient to wait for Providers to get its deposits one by one instead.
       **/
      clearInsolventFlag: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
      /**
       * Dispatchable extrinsic that allows root to add a dynamic-rate payment stream from a User to a Provider.
       *
       * The dispatch origin for this call must be Root (Payment streams should only be added by traits in other pallets,
       * this extrinsic is for manual testing).
       *
       * Parameters:
       * - `provider_id`: The Provider ID that the payment stream is for.
       * - `user_account`: The User Account ID that the payment stream is for.
       * - `amount_provided`: The initial amount provided by the Provider.
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was executed by the root origin
       * 2. Check that the payment stream does not already exist
       * 3. Check that the User has enough funds to pay the deposit
       * 4. Hold the deposit from the User
       * 5. Update the Payment Streams storage to add the new payment stream
       *
       * Emits `DynamicRatePaymentStreamCreated` event when successful.
       **/
      createDynamicRatePaymentStream: AugmentedSubmittable<
        (
          providerId: H256 | string | Uint8Array,
          userAccount: AccountId32 | string | Uint8Array,
          amountProvided: u64 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [H256, AccountId32, u64]
      >;
      /**
       * Dispatchable extrinsic that allows root to add a fixed-rate payment stream from a User to a Provider.
       *
       * The dispatch origin for this call must be Root (Payment streams should only be added by traits in other pallets,
       * this extrinsic is for manual testing).
       *
       * Parameters:
       * - `provider_id`: The Provider ID that the payment stream is for.
       * - `user_account`: The User Account ID that the payment stream is for.
       * - `rate`: The initial rate of the payment stream.
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was executed by the root origin
       * 2. Check that the payment stream does not already exist
       * 3. Check that the User has enough funds to pay the deposit
       * 4. Hold the deposit from the User
       * 5. Update the Payment Streams storage to add the new payment stream
       *
       * Emits `FixedRatePaymentStreamCreated` event when successful.
       **/
      createFixedRatePaymentStream: AugmentedSubmittable<
        (
          providerId: H256 | string | Uint8Array,
          userAccount: AccountId32 | string | Uint8Array,
          rate: u128 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [H256, AccountId32, u128]
      >;
      /**
       * Dispatchable extrinsic that allows root to delete an existing dynamic-rate payment stream between a User and a Provider.
       *
       * The dispatch origin for this call must be Root (Payment streams should only be added by traits in other pallets,
       * this extrinsic is for manual testing).
       *
       * Parameters:
       * - `provider_id`: The Provider ID that the payment stream is for.
       * - `user_account`: The User Account ID that the payment stream is for.
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was executed by the root origin
       * 2. Check that the payment stream exists
       * 3. Update the Payment Streams storage to remove the payment stream
       *
       * Emits `DynamicRatePaymentStreamDeleted` event when successful.
       **/
      deleteDynamicRatePaymentStream: AugmentedSubmittable<
        (
          providerId: H256 | string | Uint8Array,
          userAccount: AccountId32 | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [H256, AccountId32]
      >;
      /**
       * Dispatchable extrinsic that allows root to delete an existing fixed-rate payment stream between a User and a Provider.
       *
       * The dispatch origin for this call must be Root (Payment streams should only be added by traits in other pallets,
       * this extrinsic is for manual testing).
       *
       * Parameters:
       * - `provider_id`: The Provider ID that the payment stream is for.
       * - `user_account`: The User Account ID that the payment stream is for.
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was executed by the root origin
       * 2. Check that the payment stream exists
       * 3. Update the Payment Streams storage to remove the payment stream
       *
       * Emits `FixedRatePaymentStreamDeleted` event when successful.
       **/
      deleteFixedRatePaymentStream: AugmentedSubmittable<
        (
          providerId: H256 | string | Uint8Array,
          userAccount: AccountId32 | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [H256, AccountId32]
      >;
      /**
       * Dispatchable extrinsic that allows a user flagged as without funds to pay all remaining payment streams to be able to recover
       * its deposits.
       *
       * The dispatch origin for this call must be Signed.
       * The origin must be the User that has been flagged as without funds.
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was signed and get the signer.
       * 2. Check that the user has been flagged as without funds.
       * 3. Release the user's funds that were held as a deposit for each payment stream.
       * 4. Get all payment streams of the user and charge them, paying the Providers for the services.
       * 5. Delete all payment streams of the user.
       *
       * Emits a 'UserPaidDebts' event when successful.
       *
       * Notes: this extrinsic iterates over all payment streams of the user and charges them, so it can be expensive in terms of weight.
       * The fee to execute it should be high enough to compensate for the weight of the extrinsic, without being too high that the user
       * finds more convenient to wait for Providers to get its deposits one by one instead.
       **/
      payOutstandingDebt: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
      /**
       * Dispatchable extrinsic that allows root to update an existing dynamic-rate payment stream between a User and a Provider.
       *
       * The dispatch origin for this call must be Root (Payment streams should only be added by traits in other pallets,
       * this extrinsic is for manual testing).
       *
       * Parameters:
       * - `provider_id`: The Provider ID that the payment stream is for.
       * - `user_account`: The User Account ID that the payment stream is for.
       * - `new_amount_provided`: The new amount provided by the Provider.
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was executed by the root origin
       * 2. Check that the payment stream exists
       * 3. Update the Payment Streams storage to update the payment stream
       *
       * Emits `DynamicRatePaymentStreamUpdated` event when successful.
       **/
      updateDynamicRatePaymentStream: AugmentedSubmittable<
        (
          providerId: H256 | string | Uint8Array,
          userAccount: AccountId32 | string | Uint8Array,
          newAmountProvided: u64 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [H256, AccountId32, u64]
      >;
      /**
       * Dispatchable extrinsic that allows root to update an existing fixed-rate payment stream between a User and a Provider.
       *
       * The dispatch origin for this call must be Root (Payment streams should only be added by traits in other pallets,
       * this extrinsic is for manual testing).
       *
       * Parameters:
       * - `provider_id`: The Provider ID that the payment stream is for.
       * - `user_account`: The User Account ID that the payment stream is for.
       * - `new_rate`: The new rate of the payment stream.
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was executed by the root origin
       * 2. Check that the payment stream exists
       * 3. Update the Payment Streams storage to update the payment stream
       *
       * Emits `FixedRatePaymentStreamUpdated` event when successful.
       **/
      updateFixedRatePaymentStream: AugmentedSubmittable<
        (
          providerId: H256 | string | Uint8Array,
          userAccount: AccountId32 | string | Uint8Array,
          newRate: u128 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [H256, AccountId32, u128]
      >;
      /**
       * Generic tx
       **/
      [key: string]: SubmittableExtrinsicFunction<ApiType>;
    };
    polkadotXcm: {
      /**
       * Claims assets trapped on this pallet because of leftover assets during XCM execution.
       *
       * - `origin`: Anyone can call this extrinsic.
       * - `assets`: The exact assets that were trapped. Use the version to specify what version
       * was the latest when they were trapped.
       * - `beneficiary`: The location/account where the claimed assets will be deposited.
       **/
      claimAssets: AugmentedSubmittable<
        (
          assets:
            | XcmVersionedAssets
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          beneficiary:
            | XcmVersionedLocation
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [XcmVersionedAssets, XcmVersionedLocation]
      >;
      /**
       * Execute an XCM message from a local, signed, origin.
       *
       * An event is deposited indicating whether `msg` could be executed completely or only
       * partially.
       *
       * No more than `max_weight` will be used in its attempted execution. If this is less than
       * the maximum amount of weight that the message could take to be executed, then no
       * execution attempt will be made.
       **/
      execute: AugmentedSubmittable<
        (
          message: XcmVersionedXcm | { V2: any } | { V3: any } | { V4: any } | string | Uint8Array,
          maxWeight:
            | SpWeightsWeightV2Weight
            | { refTime?: any; proofSize?: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [XcmVersionedXcm, SpWeightsWeightV2Weight]
      >;
      /**
       * Set a safe XCM version (the version that XCM should be encoded with if the most recent
       * version a destination can accept is unknown).
       *
       * - `origin`: Must be an origin specified by AdminOrigin.
       * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.
       **/
      forceDefaultXcmVersion: AugmentedSubmittable<
        (
          maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber
        ) => SubmittableExtrinsic<ApiType>,
        [Option<u32>]
      >;
      /**
       * Ask a location to notify us regarding their XCM version and any changes to it.
       *
       * - `origin`: Must be an origin specified by AdminOrigin.
       * - `location`: The location to which we should subscribe for XCM version notifications.
       **/
      forceSubscribeVersionNotify: AugmentedSubmittable<
        (
          location:
            | XcmVersionedLocation
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [XcmVersionedLocation]
      >;
      /**
       * Set or unset the global suspension state of the XCM executor.
       *
       * - `origin`: Must be an origin specified by AdminOrigin.
       * - `suspended`: `true` to suspend, `false` to resume.
       **/
      forceSuspension: AugmentedSubmittable<
        (suspended: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [bool]
      >;
      /**
       * Require that a particular destination should no longer notify us regarding any XCM
       * version changes.
       *
       * - `origin`: Must be an origin specified by AdminOrigin.
       * - `location`: The location to which we are currently subscribed for XCM version
       * notifications which we no longer desire.
       **/
      forceUnsubscribeVersionNotify: AugmentedSubmittable<
        (
          location:
            | XcmVersionedLocation
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [XcmVersionedLocation]
      >;
      /**
       * Extoll that a particular destination can be communicated with through a particular
       * version of XCM.
       *
       * - `origin`: Must be an origin specified by AdminOrigin.
       * - `location`: The destination that is being described.
       * - `xcm_version`: The latest version of XCM that `location` supports.
       **/
      forceXcmVersion: AugmentedSubmittable<
        (
          location: StagingXcmV4Location | { parents?: any; interior?: any } | string | Uint8Array,
          version: u32 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [StagingXcmV4Location, u32]
      >;
      /**
       * Transfer some assets from the local chain to the destination chain through their local,
       * destination or remote reserve.
       *
       * `assets` must have same reserve location and may not be teleportable to `dest`.
       * - `assets` have local reserve: transfer assets to sovereign account of destination
       * chain and forward a notification XCM to `dest` to mint and deposit reserve-based
       * assets to `beneficiary`.
       * - `assets` have destination reserve: burn local assets and forward a notification to
       * `dest` chain to withdraw the reserve assets from this chain's sovereign account and
       * deposit them to `beneficiary`.
       * - `assets` have remote reserve: burn local assets, forward XCM to reserve chain to move
       * reserves from this chain's SA to `dest` chain's SA, and forward another XCM to `dest`
       * to mint and deposit reserve-based assets to `beneficiary`.
       *
       * Fee payment on the destination side is made from the asset in the `assets` vector of
       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight
       * is needed than `weight_limit`, then the operation will fail and the sent assets may be
       * at risk.
       *
       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.
       * - `dest`: Destination context for the assets. Will typically be `[Parent,
       * Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from
       * relay to parachain.
       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will
       * generally be an `AccountId32` value.
       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the
       * fee on the `dest` (and possibly reserve) chains.
       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay
       * fees.
       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.
       **/
      limitedReserveTransferAssets: AugmentedSubmittable<
        (
          dest:
            | XcmVersionedLocation
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          beneficiary:
            | XcmVersionedLocation
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          assets:
            | XcmVersionedAssets
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          feeAssetItem: u32 | AnyNumber | Uint8Array,
          weightLimit:
            | XcmV3WeightLimit
            | { Unlimited: any }
            | { Limited: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [XcmVersionedLocation, XcmVersionedLocation, XcmVersionedAssets, u32, XcmV3WeightLimit]
      >;
      /**
       * Teleport some assets from the local chain to some destination chain.
       *
       * Fee payment on the destination side is made from the asset in the `assets` vector of
       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight
       * is needed than `weight_limit`, then the operation will fail and the sent assets may be
       * at risk.
       *
       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.
       * - `dest`: Destination context for the assets. Will typically be `[Parent,
       * Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from
       * relay to parachain.
       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will
       * generally be an `AccountId32` value.
       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the
       * fee on the `dest` chain.
       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay
       * fees.
       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.
       **/
      limitedTeleportAssets: AugmentedSubmittable<
        (
          dest:
            | XcmVersionedLocation
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          beneficiary:
            | XcmVersionedLocation
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          assets:
            | XcmVersionedAssets
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          feeAssetItem: u32 | AnyNumber | Uint8Array,
          weightLimit:
            | XcmV3WeightLimit
            | { Unlimited: any }
            | { Limited: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [XcmVersionedLocation, XcmVersionedLocation, XcmVersionedAssets, u32, XcmV3WeightLimit]
      >;
      /**
       * Transfer some assets from the local chain to the destination chain through their local,
       * destination or remote reserve.
       *
       * `assets` must have same reserve location and may not be teleportable to `dest`.
       * - `assets` have local reserve: transfer assets to sovereign account of destination
       * chain and forward a notification XCM to `dest` to mint and deposit reserve-based
       * assets to `beneficiary`.
       * - `assets` have destination reserve: burn local assets and forward a notification to
       * `dest` chain to withdraw the reserve assets from this chain's sovereign account and
       * deposit them to `beneficiary`.
       * - `assets` have remote reserve: burn local assets, forward XCM to reserve chain to move
       * reserves from this chain's SA to `dest` chain's SA, and forward another XCM to `dest`
       * to mint and deposit reserve-based assets to `beneficiary`.
       *
       * **This function is deprecated: Use `limited_reserve_transfer_assets` instead.**
       *
       * Fee payment on the destination side is made from the asset in the `assets` vector of
       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,
       * with all fees taken as needed from the asset.
       *
       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.
       * - `dest`: Destination context for the assets. Will typically be `[Parent,
       * Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from
       * relay to parachain.
       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will
       * generally be an `AccountId32` value.
       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the
       * fee on the `dest` (and possibly reserve) chains.
       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay
       * fees.
       **/
      reserveTransferAssets: AugmentedSubmittable<
        (
          dest:
            | XcmVersionedLocation
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          beneficiary:
            | XcmVersionedLocation
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          assets:
            | XcmVersionedAssets
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          feeAssetItem: u32 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [XcmVersionedLocation, XcmVersionedLocation, XcmVersionedAssets, u32]
      >;
      send: AugmentedSubmittable<
        (
          dest:
            | XcmVersionedLocation
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          message: XcmVersionedXcm | { V2: any } | { V3: any } | { V4: any } | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [XcmVersionedLocation, XcmVersionedXcm]
      >;
      /**
       * Teleport some assets from the local chain to some destination chain.
       *
       * **This function is deprecated: Use `limited_teleport_assets` instead.**
       *
       * Fee payment on the destination side is made from the asset in the `assets` vector of
       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,
       * with all fees taken as needed from the asset.
       *
       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.
       * - `dest`: Destination context for the assets. Will typically be `[Parent,
       * Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from
       * relay to parachain.
       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will
       * generally be an `AccountId32` value.
       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the
       * fee on the `dest` chain.
       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay
       * fees.
       **/
      teleportAssets: AugmentedSubmittable<
        (
          dest:
            | XcmVersionedLocation
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          beneficiary:
            | XcmVersionedLocation
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          assets:
            | XcmVersionedAssets
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          feeAssetItem: u32 | AnyNumber | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [XcmVersionedLocation, XcmVersionedLocation, XcmVersionedAssets, u32]
      >;
      /**
       * Transfer some assets from the local chain to the destination chain through their local,
       * destination or remote reserve, or through teleports.
       *
       * Fee payment on the destination side is made from the asset in the `assets` vector of
       * index `fee_asset_item` (hence referred to as `fees`), up to enough to pay for
       * `weight_limit` of weight. If more weight is needed than `weight_limit`, then the
       * operation will fail and the sent assets may be at risk.
       *
       * `assets` (excluding `fees`) must have same reserve location or otherwise be teleportable
       * to `dest`, no limitations imposed on `fees`.
       * - for local reserve: transfer assets to sovereign account of destination chain and
       * forward a notification XCM to `dest` to mint and deposit reserve-based assets to
       * `beneficiary`.
       * - for destination reserve: burn local assets and forward a notification to `dest` chain
       * to withdraw the reserve assets from this chain's sovereign account and deposit them
       * to `beneficiary`.
       * - for remote reserve: burn local assets, forward XCM to reserve chain to move reserves
       * from this chain's SA to `dest` chain's SA, and forward another XCM to `dest` to mint
       * and deposit reserve-based assets to `beneficiary`.
       * - for teleports: burn local assets and forward XCM to `dest` chain to mint/teleport
       * assets and deposit them to `beneficiary`.
       *
       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.
       * - `dest`: Destination context for the assets. Will typically be `X2(Parent,
       * Parachain(..))` to send from parachain to parachain, or `X1(Parachain(..))` to send
       * from relay to parachain.
       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will
       * generally be an `AccountId32` value.
       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the
       * fee on the `dest` (and possibly reserve) chains.
       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay
       * fees.
       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.
       **/
      transferAssets: AugmentedSubmittable<
        (
          dest:
            | XcmVersionedLocation
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          beneficiary:
            | XcmVersionedLocation
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          assets:
            | XcmVersionedAssets
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          feeAssetItem: u32 | AnyNumber | Uint8Array,
          weightLimit:
            | XcmV3WeightLimit
            | { Unlimited: any }
            | { Limited: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [XcmVersionedLocation, XcmVersionedLocation, XcmVersionedAssets, u32, XcmV3WeightLimit]
      >;
      /**
       * Transfer assets from the local chain to the destination chain using explicit transfer
       * types for assets and fees.
       *
       * `assets` must have same reserve location or may be teleportable to `dest`. Caller must
       * provide the `assets_transfer_type` to be used for `assets`:
       * - `TransferType::LocalReserve`: transfer assets to sovereign account of destination
       * chain and forward a notification XCM to `dest` to mint and deposit reserve-based
       * assets to `beneficiary`.
       * - `TransferType::DestinationReserve`: burn local assets and forward a notification to
       * `dest` chain to withdraw the reserve assets from this chain's sovereign account and
       * deposit them to `beneficiary`.
       * - `TransferType::RemoteReserve(reserve)`: burn local assets, forward XCM to `reserve`
       * chain to move reserves from this chain's SA to `dest` chain's SA, and forward another
       * XCM to `dest` to mint and deposit reserve-based assets to `beneficiary`. Typically
       * the remote `reserve` is Asset Hub.
       * - `TransferType::Teleport`: burn local assets and forward XCM to `dest` chain to
       * mint/teleport assets and deposit them to `beneficiary`.
       *
       * On the destination chain, as well as any intermediary hops, `BuyExecution` is used to
       * buy execution using transferred `assets` identified by `remote_fees_id`.
       * Make sure enough of the specified `remote_fees_id` asset is included in the given list
       * of `assets`. `remote_fees_id` should be enough to pay for `weight_limit`. If more weight
       * is needed than `weight_limit`, then the operation will fail and the sent assets may be
       * at risk.
       *
       * `remote_fees_id` may use different transfer type than rest of `assets` and can be
       * specified through `fees_transfer_type`.
       *
       * The caller needs to specify what should happen to the transferred assets once they reach
       * the `dest` chain. This is done through the `custom_xcm_on_dest` parameter, which
       * contains the instructions to execute on `dest` as a final step.
       * This is usually as simple as:
       * `Xcm(vec![DepositAsset { assets: Wild(AllCounted(assets.len())), beneficiary }])`,
       * but could be something more exotic like sending the `assets` even further.
       *
       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.
       * - `dest`: Destination context for the assets. Will typically be `[Parent,
       * Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from
       * relay to parachain, or `(parents: 2, (GlobalConsensus(..), ..))` to send from
       * parachain across a bridge to another ecosystem destination.
       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the
       * fee on the `dest` (and possibly reserve) chains.
       * - `assets_transfer_type`: The XCM `TransferType` used to transfer the `assets`.
       * - `remote_fees_id`: One of the included `assets` to be used to pay fees.
       * - `fees_transfer_type`: The XCM `TransferType` used to transfer the `fees` assets.
       * - `custom_xcm_on_dest`: The XCM to be executed on `dest` chain as the last step of the
       * transfer, which also determines what happens to the assets on the destination chain.
       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.
       **/
      transferAssetsUsingTypeAndThen: AugmentedSubmittable<
        (
          dest:
            | XcmVersionedLocation
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          assets:
            | XcmVersionedAssets
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          assetsTransferType:
            | StagingXcmExecutorAssetTransferTransferType
            | { Teleport: any }
            | { LocalReserve: any }
            | { DestinationReserve: any }
            | { RemoteReserve: any }
            | string
            | Uint8Array,
          remoteFeesId: XcmVersionedAssetId | { V3: any } | { V4: any } | string | Uint8Array,
          feesTransferType:
            | StagingXcmExecutorAssetTransferTransferType
            | { Teleport: any }
            | { LocalReserve: any }
            | { DestinationReserve: any }
            | { RemoteReserve: any }
            | string
            | Uint8Array,
          customXcmOnDest:
            | XcmVersionedXcm
            | { V2: any }
            | { V3: any }
            | { V4: any }
            | string
            | Uint8Array,
          weightLimit:
            | XcmV3WeightLimit
            | { Unlimited: any }
            | { Limited: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [
          XcmVersionedLocation,
          XcmVersionedAssets,
          StagingXcmExecutorAssetTransferTransferType,
          XcmVersionedAssetId,
          StagingXcmExecutorAssetTransferTransferType,
          XcmVersionedXcm,
          XcmV3WeightLimit
        ]
      >;
      /**
       * Generic tx
       **/
      [key: string]: SubmittableExtrinsicFunction<ApiType>;
    };
    proofsDealer: {
      /**
       * Introduce a new challenge.
       *
       * This function allows anyone to add a new challenge to the `ChallengesQueue`.
       * The challenge will be dispatched in the coming blocks.
       * Users are charged a small fee for submitting a challenge, which
       * goes to the Treasury.
       **/
      challenge: AugmentedSubmittable<
        (key: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [H256]
      >;
      /**
       * Initialise a Provider's challenge cycle.
       *
       * Only callable by sudo.
       *
       * Sets the last tick the Provider submitted a proof for to the current tick, and sets the
       * deadline for submitting a proof to the current tick + the Provider's period + the tolerance.
       **/
      forceInitialiseChallengeCycle: AugmentedSubmittable<
        (provider: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [H256]
      >;
      /**
       * Set the [`ChallengesTickerPaused`] to `true` or `false`.
       *
       * Only callable by sudo.
       **/
      setPaused: AugmentedSubmittable<
        (paused: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [bool]
      >;
      /**
       * For a Provider to submit a proof.
       *
       * Checks that `provider` is a registered Provider. If none
       * is provided, the proof submitter is considered to be the Provider.
       * Relies on a Providers pallet to get the root for the Provider.
       * Validates that the proof corresponds to a challenge that was made in the past,
       * by checking the `TickToChallengesSeed` StorageMap. The challenge tick that the
       * Provider should have submitted a proof is calculated based on the last tick they
       * submitted a proof for ([`LastTickProviderSubmittedAProofFor`]), and the proving period for
       * that Provider, which is a function of their stake.
       * This extrinsic also checks that there hasn't been a checkpoint challenge round
       * in between the last time the Provider submitted a proof for and the tick
       * for which the proof is being submitted. If there has been, the Provider is
       * subject to slashing.
       *
       * If valid:
       * - Pushes forward the Provider in the [`TickToProvidersDeadlines`] StorageMap a number
       * of ticks corresponding to the stake of the Provider.
       * - Registers this tick as the last tick in which the Provider submitted a proof.
       *
       * Execution of this extrinsic should be refunded if the proof is valid.
       **/
      submitProof: AugmentedSubmittable<
        (
          proof:
            | PalletProofsDealerProof
            | { forestProof?: any; keyProofs?: any }
            | string
            | Uint8Array,
          provider: Option<H256> | null | Uint8Array | H256 | string
        ) => SubmittableExtrinsic<ApiType>,
        [PalletProofsDealerProof, Option<H256>]
      >;
      /**
       * Generic tx
       **/
      [key: string]: SubmittableExtrinsicFunction<ApiType>;
    };
    providers: {
      /**
       * Dispatchable extrinsic only callable by an MSP that allows it to add a value proposition to its service
       *
       * The dispatch origin for this call must be Signed.
       * The origin must be the account that wants to add a value proposition.
       *
       * Parameters:
       * - `new_value_prop`: The value proposition that the MSP wants to add to its service.
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was signed and get the signer.
       * 2. Check that the signer is registered as a MSP
       * 3. Check that the MSP has not reached the maximum amount of value propositions
       * 4. Check that the value proposition is valid (size and any other relevant checks)
       * 5. Update the MSPs storage to add the value proposition (with its identifier)
       *
       * Emits `ValuePropAdded` event when successful.
       **/
      addValueProp: AugmentedSubmittable<
        (
          newValueProp:
            | PalletStorageProvidersValueProposition
            | { identifier?: any; dataLimit?: any; protocols?: any }
            | string
            | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [PalletStorageProvidersValueProposition]
      >;
      /**
       * Dispatchable extrinsic that allows users to sign off as a Backup Storage Provider.
       *
       * The dispatch origin for this call must be Signed.
       * The origin must be the account that wants to sign off as a Backup Storage Provider.
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was signed and get the signer.
       * 2. Check that the signer is registered as a BSP
       * 3. Check that the BSP has no storage assigned to it
       * 4. Update the BSPs storage, removing the signer as an BSP
       * 5. Update the total capacity of all BSPs, removing the capacity of the signer
       * 6. Return the deposit to the signer
       * 7. Decrement the storage that holds total amount of BSPs currently in the system
       *
       * Emits `BspSignOffSuccess` event when successful.
       **/
      bspSignOff: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
      /**
       * Dispatchable extrinsic that allows a user with a pending Sign Up Request to cancel it, getting the deposit back.
       *
       * The dispatch origin for this call must be Signed.
       * The origin must be the account that requested to sign up as a Storage Provider.
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was signed and get the signer.
       * 2. Check that the signer has requested to sign up as a SP
       * 3. Delete the request from the Sign Up Requests storage
       * 4. Return the deposit to the signer
       *
       * Emits `SignUpRequestCanceled` event when successful.
       **/
      cancelSignUp: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
      /**
       * Dispatchable extrinsic that allows users to change their amount of stored data
       *
       * The dispatch origin for this call must be Signed.
       * The origin must be the account that wants to change its capacity.
       *
       * Parameters:
       * - `new_capacity`: The new total amount of data that the Storage Provider wants to be able to store.
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was signed and get the signer.
       * 2. Check that the signer is registered as a SP
       * 3. Check that enough time has passed since the last time the SP changed its capacity
       * 4. Check that the new capacity is greater than the minimum required by the runtime
       * 5. Check that the new capacity is greater than the data used by this SP
       * 6. Calculate the new deposit needed for this new capacity
       * 7. Check to see if the new deposit needed is greater or less than the current deposit
       * a. If the new deposit is greater than the current deposit:
       * i. Check that the signer has enough funds to pay this extra deposit
       * ii. Hold the extra deposit from the signer
       * b. If the new deposit is less than the current deposit, return the held difference to the signer
       * 7. Update the SPs storage to change the total data
       * 8. If user is a BSP, update the total capacity of the network (sum of all capacities of BSPs)
       *
       * Emits `CapacityChanged` event when successful.
       **/
      changeCapacity: AugmentedSubmittable<
        (newCapacity: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [u64]
      >;
      /**
       * Dispatchable extrinsic that allows users to confirm their sign up as a Storage Provider, either MSP or BSP.
       *
       * The dispatch origin for this call must be Signed.
       * The origin must be the account that requested to sign up as a Storage Provider, except when providing a
       * `provider_account` parameter, in which case the origin can be any account.
       *
       * Parameters:
       * - `provider_account`: The account that requested to sign up as a Storage Provider. If not provided, the signer
       * will be considered the account that requested to sign up.
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was signed
       * 2. Check that the account received has requested to register as a SP
       * 3. Check that the current randomness is sufficiently fresh to be used as a salt for that request
       * 4. Check that the request has not expired
       * 5. Register the signer as a MSP or BSP with the data provided in the request
       *
       * Emits `MspSignUpSuccess` or `BspSignUpSuccess` event when successful, depending on the type of sign up.
       *
       * Notes:
       * - This extrinsic could be called by the user itself or by a third party
       * - The deposit that the user has to pay to register as a SP is held when the user requests to register as a SP
       * - If this extrinsic is successful, it will be free for the caller, to incentive state debloating
       **/
      confirmSignUp: AugmentedSubmittable<
        (
          providerAccount: Option<AccountId32> | null | Uint8Array | AccountId32 | string
        ) => SubmittableExtrinsic<ApiType>,
        [Option<AccountId32>]
      >;
      /**
       * Dispatchable extrinsic that allows to forcefully and automatically sing up a Backup Storage Provider.
       *
       * The dispatch origin for this call must be Root.
       * The `who` parameter is the account that wants to sign up as a Backup Storage Provider.
       *
       * Funds proportional to the capacity requested are reserved (held) from the account passed as the `who` parameter.
       *
       * Parameters:
       * - `who`: The account that wants to sign up as a Backup Storage Provider.
       * - `bsp_id`: The Backup Storage Provider ID that the account passed as the `who` parameter is requesting to sign up as.
       * - `capacity`: The total amount of data that the Backup Storage Provider will be able to store.
       * - `multiaddresses`: The vector of multiaddresses that the signer wants to register (according to the
       * [Multiaddr spec](https://github.com/multiformats/multiaddr))
       *
       * This extrinsic will perform the steps of:
       * 1. [request_bsp_sign_up](crate::dispatchables::request_bsp_sign_up)
       * 2. [confirm_sign_up](crate::dispatchables::confirm_sign_up)
       *
       * Emits `BspRequestSignUpSuccess` and `BspSignUpSuccess` events when successful.
       **/
      forceBspSignUp: AugmentedSubmittable<
        (
          who: AccountId32 | string | Uint8Array,
          bspId: H256 | string | Uint8Array,
          capacity: u64 | AnyNumber | Uint8Array,
          multiaddresses: Vec<Bytes> | (Bytes | string | Uint8Array)[],
          paymentAccount: AccountId32 | string | Uint8Array,
          weight: Option<u32> | null | Uint8Array | u32 | AnyNumber
        ) => SubmittableExtrinsic<ApiType>,
        [AccountId32, H256, u64, Vec<Bytes>, AccountId32, Option<u32>]
      >;
      /**
       * Dispatchable extrinsic that allows to forcefully and automatically sing up a Main Storage Provider.
       *
       * The dispatch origin for this call must be Root.
       * The `who` parameter is the account that wants to sign up as a Main Storage Provider.
       *
       * Funds proportional to the capacity requested are reserved (held) from the account passed as the `who` parameter.
       *
       * Parameters:
       * - `who`: The account that wants to sign up as a Main Storage Provider.
       * - `msp_id`: The Main Storage Provider ID that the account passed as the `who` parameter is requesting to sign up as.
       * - `capacity`: The total amount of data that the Main Storage Provider will be able to store.
       * - `multiaddresses`: The vector of multiaddresses that the signer wants to register (according to the
       * [Multiaddr spec](https://github.com/multiformats/multiaddr))
       * - `value_prop`: The value proposition that the signer will provide as a Main Storage Provider to
       * users and wants to register on-chain. It could be data limits, communication protocols to access the user's
       * data, and more.
       *
       * This extrinsic will perform the steps of:
       * 1. [request_msp_sign_up](crate::dispatchables::request_msp_sign_up)
       * 2. [confirm_sign_up](crate::dispatchables::confirm_sign_up)
       *
       * Emits `MspRequestSignUpSuccess` and `MspSignUpSuccess` events when successful.
       **/
      forceMspSignUp: AugmentedSubmittable<
        (
          who: AccountId32 | string | Uint8Array,
          mspId: H256 | string | Uint8Array,
          capacity: u64 | AnyNumber | Uint8Array,
          multiaddresses: Vec<Bytes> | (Bytes | string | Uint8Array)[],
          valueProp:
            | PalletStorageProvidersValueProposition
            | { identifier?: any; dataLimit?: any; protocols?: any }
            | string
            | Uint8Array,
          paymentAccount: AccountId32 | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [AccountId32, H256, u64, Vec<Bytes>, PalletStorageProvidersValueProposition, AccountId32]
      >;
      /**
       * Dispatchable extrinsic that allows users to sign off as a Main Storage Provider.
       *
       * The dispatch origin for this call must be Signed.
       * The origin must be the account that wants to sign off as a Main Storage Provider.
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was signed and get the signer.
       * 2. Check that the signer is registered as a MSP
       * 3. Check that the MSP has no storage assigned to it (no buckets or data used by it)
       * 4. Update the MSPs storage, removing the signer as an MSP
       * 5. Return the deposit to the signer
       * 6. Decrement the storage that holds total amount of MSPs currently in the system
       *
       * Emits `MspSignOffSuccess` event when successful.
       **/
      mspSignOff: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
      /**
       * Dispatchable extrinsic that allows users to sign up as a Backup Storage Provider.
       *
       * The dispatch origin for this call must be Signed.
       * The origin must be the account that wants to sign up as a Backup Storage Provider.
       *
       * Funds proportional to the capacity requested are reserved (held) from the account.
       *
       * Parameters:
       * - `capacity`: The total amount of data that the Backup Storage Provider will be able to store.
       * - `multiaddresses`: The vector of multiaddresses that the signer wants to register (according to the
       * [Multiaddr spec](https://github.com/multiformats/multiaddr))
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was signed and get the signer.
       * 2. Check that the signer is not already registered as either a MSP or BSP
       * 3. Check that the multiaddress is valid
       * 4. Check that the data to be stored is greater than the minimum required by the runtime
       * 5. Calculate how much deposit will the signer have to pay using the amount of data it wants to store
       * 6. Check that the signer has enough funds to pay the deposit
       * 7. Hold the deposit from the signer
       * 8. Update the Sign Up Requests storage to add the signer as requesting to sign up as a BSP
       *
       * Emits `BspRequestSignUpSuccess` event when successful.
       **/
      requestBspSignUp: AugmentedSubmittable<
        (
          capacity: u64 | AnyNumber | Uint8Array,
          multiaddresses: Vec<Bytes> | (Bytes | string | Uint8Array)[],
          paymentAccount: AccountId32 | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u64, Vec<Bytes>, AccountId32]
      >;
      /**
       * Dispatchable extrinsic that allows users to request to sign up as a Main Storage Provider.
       *
       * The dispatch origin for this call must be Signed.
       * The origin must be the account that wants to sign up as a Main Storage Provider.
       *
       * Funds proportional to the capacity requested are reserved (held) from the account.
       *
       * Parameters:
       * - `capacity`: The total amount of data that the Main Storage Provider will be able to store.
       * - `multiaddresses`: The vector of multiaddresses that the signer wants to register (according to the
       * [Multiaddr spec](https://github.com/multiformats/multiaddr))
       * - `value_prop`: The value proposition that the signer will provide as a Main Storage Provider to
       * users and wants to register on-chain. It could be data limits, communication protocols to access the user's
       * data, and more.
       *
       * This extrinsic will perform the following checks and logic:
       * 1. Check that the extrinsic was signed and get the signer.
       * 2. Check that the signer is not already registered as either a MSP or BSP
       * 3. Check that the multiaddress is valid
       * 4. Check that the data to be stored is greater than the minimum required by the runtime.
       * 5. Calculate how much deposit will the signer have to pay using the amount of data it wants to store
       * 6. Check that the signer has enough funds to pay the deposit
       * 7. Hold the deposit from the signer
       * 8. Update the Sign Up Requests storage to add the signer as requesting to sign up as a MSP
       *
       * Emits `MspRequestSignUpSuccess` event when successful.
       **/
      requestMspSignUp: AugmentedSubmittable<
        (
          capacity: u64 | AnyNumber | Uint8Array,
          multiaddresses: Vec<Bytes> | (Bytes | string | Uint8Array)[],
          valueProp:
            | PalletStorageProvidersValueProposition
            | { identifier?: any; dataLimit?: any; protocols?: any }
            | string
            | Uint8Array,
          paymentAccount: AccountId32 | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [u64, Vec<Bytes>, PalletStorageProvidersValueProposition, AccountId32]
      >;
      /**
       * Dispatchable extrinsic to slash a _slashable_ Storage Provider.
       *
       * A Storage Provider is _slashable_ iff it has failed to respond to challenges for providing proofs of storage.
       * In the context of the StorageHub protocol, the proofs-dealer pallet marks a Storage Provider as _slashable_ when it fails to respond to challenges.
       **/
      slash: AugmentedSubmittable<
        (providerId: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [H256]
      >;
      /**
       * Generic tx
       **/
      [key: string]: SubmittableExtrinsicFunction<ApiType>;
    };
    randomness: {
      /**
       * This inherent that must be included (DispatchClass::Mandatory) at each block saves the latest randomness available from the
       * relay chain into a variable that can then be used as a seed for commitments that happened during
       * the previous relay chain epoch
       **/
      setBabeRandomness: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
      /**
       * 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: StorageHubRuntimeSessionKeys | { aura?: any } | string | Uint8Array,
          proof: Bytes | string | Uint8Array
        ) => SubmittableExtrinsic<ApiType>,
        [StorageHubRuntimeSessionKeys, Bytes]
      >;
      /**
       * 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>;
    };
    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>;
    };
    xcmpQueue: {
      /**
       * Resumes all XCM executions for the XCMP queue.
       *
       * Note that this function doesn't change the status of the in/out bound channels.
       *
       * - `origin`: Must pass `ControllerOrigin`.
       **/
      resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
      /**
       * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.
       *
       * - `origin`: Must pass `ControllerOrigin`.
       **/
      suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
      /**
       * Overwrites the number of pages which must be in the queue after which we drop any
       * further messages from the channel.
       *
       * - `origin`: Must pass `Root`.
       * - `new`: Desired value for `QueueConfigData.drop_threshold`
       **/
      updateDropThreshold: AugmentedSubmittable<
        (updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [u32]
      >;
      /**
       * Overwrites the number of pages which the queue must be reduced to before it signals
       * that message sending may recommence after it has been suspended.
       *
       * - `origin`: Must pass `Root`.
       * - `new`: Desired value for `QueueConfigData.resume_threshold`
       **/
      updateResumeThreshold: AugmentedSubmittable<
        (updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [u32]
      >;
      /**
       * Overwrites the number of pages which must be in the queue for the other side to be
       * told to suspend their sending.
       *
       * - `origin`: Must pass `Root`.
       * - `new`: Desired value for `QueueConfigData.suspend_value`
       **/
      updateSuspendThreshold: AugmentedSubmittable<
        (updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>,
        [u32]
      >;
      /**
       * Generic tx
       **/
      [key: string]: SubmittableExtrinsicFunction<ApiType>;
    };
  } // AugmentedSubmittables
} // declare module