git.delta.rocks / unique-network / refs/commits / 768e7a342d72

1// Auto-generated via `yarn polkadot-types-from-chain`, do not edit2/* eslint-disable */34// import type lookup before we augment - in some environments5// this is required to allow for ambient/previous definitions6import '@polkadot/api-base/types/submittable';78import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types';9import type { Data } from '@polkadot/types';10import type { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';11import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';12import type { AccountId32, Call, H160, H256, MultiAddress } from '@polkadot/types/interfaces/runtime';13import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumLog, EthereumTransactionTransactionV2, OpalRuntimeRuntimeCommonSessionKeys, OrmlVestingVestingSchedule, PalletConfigurationAppPromotionConfiguration, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletIdentityBitFlags, PalletIdentityIdentityInfo, PalletIdentityJudgement, PalletIdentityRegistration, SpWeightsWeightV2Weight, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV3MultiLocation, XcmV3WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';1415export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;16export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;17export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;1819declare module '@polkadot/api-base/types/submittable' {20  interface AugmentedSubmittables<ApiType extends ApiTypes> {21    appPromotion: {22      /**23       * Recalculates interest for the specified number of stakers.24       * If all stakers are not recalculated, the next call of the extrinsic25       * will continue the recalculation, from those stakers for whom this26       * was not perform in last call.27       * 28       * # Permissions29       * 30       * * Pallet admin31       * 32       * # Arguments33       * 34       * * `stakers_number`: the number of stakers for which recalculation will be performed35       **/36      payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;37      /**38       * Sets an address as the the admin.39       * 40       * # Permissions41       * 42       * * Sudo43       * 44       * # Arguments45       * 46       * * `admin`: account of the new admin.47       **/48      setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;49      /**50       * Sets the pallet to be the sponsor for the collection.51       * 52       * # Permissions53       * 54       * * Pallet admin55       * 56       * # Arguments57       * 58       * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`59       **/60      sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;61      /**62       * Sets the pallet to be the sponsor for the contract.63       * 64       * # Permissions65       * 66       * * Pallet admin67       * 68       * # Arguments69       * 70       * * `contract_id`: the contract address that will be sponsored by `pallet_id`71       **/72      sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;73      /**74       * Stakes the amount of native tokens.75       * Sets `amount` to the locked state.76       * The maximum number of stakes for a staker is 10.77       * 78       * # Arguments79       * 80       * * `amount`: in native tokens.81       **/82      stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;83      /**84       * Removes the pallet as the sponsor for the collection.85       * Returns [`NoPermission`][`Error::NoPermission`]86       * if the pallet wasn't the sponsor.87       * 88       * # Permissions89       * 90       * * Pallet admin91       * 92       * # Arguments93       * 94       * * `collection_id`: ID of the collection that is sponsored by `pallet_id`95       **/96      stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;97      /**98       * Removes the pallet as the sponsor for the contract.99       * Returns [`NoPermission`][`Error::NoPermission`]100       * if the pallet wasn't the sponsor.101       * 102       * # Permissions103       * 104       * * Pallet admin105       * 106       * # Arguments107       * 108       * * `contract_id`: the contract address that is sponsored by `pallet_id`109       **/110      stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;111      /**112       * Unstakes all stakes.113       * After the end of `PendingInterval` this sum becomes completely114       * free for further use.115       **/116      unstakeAll: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;117      /**118       * Unstakes the amount of balance for the staker.119       * After the end of `PendingInterval` this sum becomes completely120       * free for further use.121       * 122       * # Arguments123       * 124       * * `staker`: staker account.125       * * `amount`: amount of unstaked funds.126       **/127      unstakePartial: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;128      /**129       * Generic tx130       **/131      [key: string]: SubmittableExtrinsicFunction<ApiType>;132    };133    balances: {134      /**135       * Exactly as `transfer`, except the origin must be root and the source account may be136       * specified.137       * ## Complexity138       * - Same as transfer, but additional read and write because the source account is not139       * assumed to be in the overlay.140       **/141      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>]>;142      /**143       * Unreserve some balance from a user by force.144       * 145       * Can only be called by ROOT.146       **/147      forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;148      /**149       * Set the balances of a given account.150       * 151       * This will alter `FreeBalance` and `ReservedBalance` in storage. it will152       * also alter the total issuance of the system (`TotalIssuance`) appropriately.153       * If the new free or reserved balance is below the existential deposit,154       * it will reset the account nonce (`frame_system::AccountNonce`).155       * 156       * The dispatch origin for this call is `root`.157       **/158      setBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, newReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>, Compact<u128>]>;159      /**160       * Transfer some liquid free balance to another account.161       * 162       * `transfer` will set the `FreeBalance` of the sender and receiver.163       * If the sender's account is below the existential deposit as a result164       * of the transfer, the account will be reaped.165       * 166       * The dispatch origin for this call must be `Signed` by the transactor.167       * 168       * ## Complexity169       * - Dependent on arguments but not critical, given proper implementations for input config170       * types. See related functions below.171       * - It contains a limited number of reads and writes internally and no complex172       * computation.173       * 174       * Related functions:175       * 176       * - `ensure_can_withdraw` is always called internally but has a bounded complexity.177       * - Transferring balances to accounts that did not exist before will cause178       * `T::OnNewAccount::on_new_account` to be called.179       * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.180       * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check181       * that the transfer will not kill the origin account.182       **/183      transfer: 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>]>;184      /**185       * Transfer the entire transferable balance from the caller account.186       * 187       * NOTE: This function only attempts to transfer _transferable_ balances. This means that188       * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be189       * transferred by this function. To ensure that this function results in a killed account,190       * you might need to prepare the account by removing any reference counters, storage191       * deposits, etc...192       * 193       * The dispatch origin of this call must be Signed.194       * 195       * - `dest`: The recipient of the transfer.196       * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all197       * of the funds the account has, causing the sender account to be killed (false), or198       * transfer everything except at least the existential deposit, which will guarantee to199       * keep the sender account alive (true). ## Complexity200       * - O(1). Just like transfer, but reading the user's transferable balance first.201       **/202      transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;203      /**204       * Same as the [`transfer`] call, but with a check that the transfer will not kill the205       * origin account.206       * 207       * 99% of the time you want [`transfer`] instead.208       * 209       * [`transfer`]: struct.Pallet.html#method.transfer210       **/211      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>]>;212      /**213       * Generic tx214       **/215      [key: string]: SubmittableExtrinsicFunction<ApiType>;216    };217    charging: {218      /**219       * Generic tx220       **/221      [key: string]: SubmittableExtrinsicFunction<ApiType>;222    };223    collatorSelection: {224      /**225       * Add a collator to the list of invulnerable (fixed) collators.226       **/227      addInvulnerable: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;228      /**229       * Force deregister `origin` as a collator candidate as a governing authority, and revoke its license.230       * Note that the collator can only leave on session change.231       * The `LicenseBond` will be unreserved and returned immediately.232       * 233       * This call is, of course, not applicable to `Invulnerable` collators.234       **/235      forceReleaseLicense: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;236      /**237       * Purchase a license on block collation for this account.238       * It does not make it a collator candidate, use `onboard` afterward. The account must239       * (a) already have registered session keys and (b) be able to reserve the `LicenseBond`.240       * 241       * This call is not available to `Invulnerable` collators.242       **/243      getLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;244      /**245       * Deregister `origin` as a collator candidate. Note that the collator can only leave on246       * session change. The license to `onboard` later at any other time will remain.247       **/248      offboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;249      /**250       * Register this account as a candidate for collators for next sessions.251       * The account must already hold a license, and cannot offboard immediately during a session.252       * 253       * This call is not available to `Invulnerable` collators.254       **/255      onboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;256      /**257       * Forfeit `origin`'s own license. The `LicenseBond` will be unreserved immediately.258       * 259       * This call is not available to `Invulnerable` collators.260       **/261      releaseLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;262      /**263       * Remove a collator from the list of invulnerable (fixed) collators.264       **/265      removeInvulnerable: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;266      /**267       * Generic tx268       **/269      [key: string]: SubmittableExtrinsicFunction<ApiType>;270    };271    configuration: {272      setAppPromotionConfigurationOverride: AugmentedSubmittable<(configuration: PalletConfigurationAppPromotionConfiguration | { recalculationInterval?: any; pendingInterval?: any; intervalIncome?: any; maxStakersPerCalculation?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletConfigurationAppPromotionConfiguration]>;273      setCollatorSelectionDesiredCollators: AugmentedSubmittable<(max: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;274      setCollatorSelectionKickThreshold: AugmentedSubmittable<(threshold: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;275      setCollatorSelectionLicenseBond: AugmentedSubmittable<(amount: Option<u128> | null | Uint8Array | u128 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u128>]>;276      setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;277      setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;278      /**279       * Generic tx280       **/281      [key: string]: SubmittableExtrinsicFunction<ApiType>;282    };283    cumulusXcm: {284      /**285       * Generic tx286       **/287      [key: string]: SubmittableExtrinsicFunction<ApiType>;288    };289    dmpQueue: {290      /**291       * Service a single overweight message.292       **/293      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, SpWeightsWeightV2Weight]>;294      /**295       * Generic tx296       **/297      [key: string]: SubmittableExtrinsicFunction<ApiType>;298    };299    ethereum: {300      /**301       * Transact an Ethereum transaction.302       **/303      transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;304      /**305       * Generic tx306       **/307      [key: string]: SubmittableExtrinsicFunction<ApiType>;308    };309    evm: {310      /**311       * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.312       **/313      call: AugmentedSubmittable<(source: H160 | string | Uint8Array, target: H160 | string | Uint8Array, input: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, H160, Bytes, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;314      /**315       * Issue an EVM create operation. This is similar to a contract creation transaction in316       * Ethereum.317       **/318      create: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, Bytes, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;319      /**320       * Issue an EVM create2 operation.321       **/322      create2: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, salt: H256 | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, Bytes, H256, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;323      /**324       * Withdraw balance from EVM into currency/balances pallet.325       **/326      withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;327      /**328       * Generic tx329       **/330      [key: string]: SubmittableExtrinsicFunction<ApiType>;331    };332    evmCoderSubstrate: {333      emptyCall: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;334      /**335       * Generic tx336       **/337      [key: string]: SubmittableExtrinsicFunction<ApiType>;338    };339    evmContractHelpers: {340      /**341       * Migrate contract to use `SponsoringMode` storage instead of `SelfSponsoring`342       **/343      migrateFromSelfSponsoring: AugmentedSubmittable<(addresses: Vec<H160> | (H160 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<H160>]>;344      /**345       * Generic tx346       **/347      [key: string]: SubmittableExtrinsicFunction<ApiType>;348    };349    evmMigration: {350      /**351       * Start contract migration, inserts contract stub at target address,352       * and marks account as pending, allowing to insert storage353       **/354      begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;355      /**356       * Finish contract migration, allows it to be called.357       * It is not possible to alter contract storage via [`Self::set_data`]358       * after this call.359       **/360      finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;361      /**362       * Create ethereum events attached to the fake transaction363       **/364      insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;365      /**366       * Create substrate events367       **/368      insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;369      /**370       * Remove remark compatibility data leftovers371       **/372      removeRmrkData: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;373      /**374       * Insert items into contract storage, this method can be called375       * multiple times376       **/377      setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;378      /**379       * Generic tx380       **/381      [key: string]: SubmittableExtrinsicFunction<ApiType>;382    };383    foreignAssets: {384      registerForeignAsset: AugmentedSubmittable<(owner: AccountId32 | string | Uint8Array, location: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;385      updateForeignAsset: AugmentedSubmittable<(foreignAssetId: u32 | AnyNumber | Uint8Array, location: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;386      /**387       * Generic tx388       **/389      [key: string]: SubmittableExtrinsicFunction<ApiType>;390    };391    identity: {392      /**393       * Add a registrar to the system.394       * 395       * The dispatch origin for this call must be `T::RegistrarOrigin`.396       * 397       * - `account`: the account of the registrar.398       * 399       * Emits `RegistrarAdded` if successful.400       * 401       * # <weight>402       * - `O(R)` where `R` registrar-count (governance-bounded and code-bounded).403       * - One storage mutation (codec `O(R)`).404       * - One event.405       * # </weight>406       **/407      addRegistrar: AugmentedSubmittable<(account: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;408      /**409       * Add the given account to the sender's subs.410       * 411       * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated412       * to the sender.413       * 414       * The dispatch origin for this call must be _Signed_ and the sender must have a registered415       * sub identity of `sub`.416       **/417      addSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, data: Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Data]>;418      /**419       * Cancel a previous request.420       * 421       * Payment: A previously reserved deposit is returned on success.422       * 423       * The dispatch origin for this call must be _Signed_ and the sender must have a424       * registered identity.425       * 426       * - `reg_index`: The index of the registrar whose judgement is no longer requested.427       * 428       * Emits `JudgementUnrequested` if successful.429       * 430       * # <weight>431       * - `O(R + X)`.432       * - One balance-reserve operation.433       * - One storage mutation `O(R + X)`.434       * - One event435       * # </weight>436       **/437      cancelRequest: AugmentedSubmittable<(regIndex: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;438      /**439       * Clear an account's identity info and all sub-accounts and return all deposits.440       * 441       * Payment: All reserved balances on the account are returned.442       * 443       * The dispatch origin for this call must be _Signed_ and the sender must have a registered444       * identity.445       * 446       * Emits `IdentityCleared` if successful.447       * 448       * # <weight>449       * - `O(R + S + X)`450       * - where `R` registrar-count (governance-bounded).451       * - where `S` subs-count (hard- and deposit-bounded).452       * - where `X` additional-field-count (deposit-bounded and code-bounded).453       * - One balance-unreserve operation.454       * - `2` storage reads and `S + 2` storage deletions.455       * - One event.456       * # </weight>457       **/458      clearIdentity: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;459      /**460       * Set identities to be associated with the provided accounts as force origin.461       * 462       * This is not meant to operate in tandem with the identity pallet as is,463       * and be instead used to keep identities made and verified externally,464       * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.465       **/466      forceInsertIdentities: AugmentedSubmittable<(identities: Vec<ITuple<[AccountId32, PalletIdentityRegistration]>> | ([AccountId32 | string | Uint8Array, PalletIdentityRegistration | { judgements?: any; deposit?: any; info?: any } | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[AccountId32, PalletIdentityRegistration]>>]>;467      /**468       * Remove identities associated with the provided accounts as force origin.469       * 470       * This is not meant to operate in tandem with the identity pallet as is,471       * and be instead used to keep identities made and verified externally,472       * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.473       **/474      forceRemoveIdentities: AugmentedSubmittable<(identities: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;475      /**476       * Set sub-identities to be associated with the provided accounts as force origin.477       * 478       * This is not meant to operate in tandem with the identity pallet as is,479       * and be instead used to keep identities made and verified externally,480       * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.481       **/482      forceSetSubs: AugmentedSubmittable<(subs: Vec<ITuple<[AccountId32, ITuple<[u128, Vec<ITuple<[AccountId32, Data]>>]>]>> | ([AccountId32 | string | Uint8Array, ITuple<[u128, Vec<ITuple<[AccountId32, Data]>>]> | [u128 | AnyNumber | Uint8Array, Vec<ITuple<[AccountId32, Data]>> | ([AccountId32 | string | Uint8Array, Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array])[]]])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[AccountId32, ITuple<[u128, Vec<ITuple<[AccountId32, Data]>>]>]>>]>;483      /**484       * Remove an account's identity and sub-account information and slash the deposits.485       * 486       * Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled by487       * `Slash`. Verification request deposits are not returned; they should be cancelled488       * manually using `cancel_request`.489       * 490       * The dispatch origin for this call must match `T::ForceOrigin`.491       * 492       * - `target`: the account whose identity the judgement is upon. This must be an account493       * with a registered identity.494       * 495       * Emits `IdentityKilled` if successful.496       * 497       * # <weight>498       * - `O(R + S + X)`.499       * - One balance-reserve operation.500       * - `S + 2` storage mutations.501       * - One event.502       * # </weight>503       **/504      killIdentity: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;505      /**506       * Provide a judgement for an account's identity.507       * 508       * The dispatch origin for this call must be _Signed_ and the sender must be the account509       * of the registrar whose index is `reg_index`.510       * 511       * - `reg_index`: the index of the registrar whose judgement is being made.512       * - `target`: the account whose identity the judgement is upon. This must be an account513       * with a registered identity.514       * - `judgement`: the judgement of the registrar of index `reg_index` about `target`.515       * - `identity`: The hash of the [`IdentityInfo`] for that the judgement is provided.516       * 517       * Emits `JudgementGiven` if successful.518       * 519       * # <weight>520       * - `O(R + X)`.521       * - One balance-transfer operation.522       * - Up to one account-lookup operation.523       * - Storage: 1 read `O(R)`, 1 mutate `O(R + X)`.524       * - One event.525       * # </weight>526       **/527      provideJudgement: AugmentedSubmittable<(regIndex: Compact<u32> | AnyNumber | Uint8Array, target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, judgement: PalletIdentityJudgement | { Unknown: any } | { FeePaid: any } | { Reasonable: any } | { KnownGood: any } | { OutOfDate: any } | { LowQuality: any } | { Erroneous: any } | string | Uint8Array, identity: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, MultiAddress, PalletIdentityJudgement, H256]>;528      /**529       * Remove the sender as a sub-account.530       * 531       * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated532       * to the sender (*not* the original depositor).533       * 534       * The dispatch origin for this call must be _Signed_ and the sender must have a registered535       * super-identity.536       * 537       * NOTE: This should not normally be used, but is provided in the case that the non-538       * controller of an account is maliciously registered as a sub-account.539       **/540      quitSub: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;541      /**542       * Remove the given account from the sender's subs.543       * 544       * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated545       * to the sender.546       * 547       * The dispatch origin for this call must be _Signed_ and the sender must have a registered548       * sub identity of `sub`.549       **/550      removeSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;551      /**552       * Alter the associated name of the given sub-account.553       * 554       * The dispatch origin for this call must be _Signed_ and the sender must have a registered555       * sub identity of `sub`.556       **/557      renameSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, data: Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Data]>;558      /**559       * Request a judgement from a registrar.560       * 561       * Payment: At most `max_fee` will be reserved for payment to the registrar if judgement562       * given.563       * 564       * The dispatch origin for this call must be _Signed_ and the sender must have a565       * registered identity.566       * 567       * - `reg_index`: The index of the registrar whose judgement is requested.568       * - `max_fee`: The maximum fee that may be paid. This should just be auto-populated as:569       * 570       * ```nocompile571       * Self::registrars().get(reg_index).unwrap().fee572       * ```573       * 574       * Emits `JudgementRequested` if successful.575       * 576       * # <weight>577       * - `O(R + X)`.578       * - One balance-reserve operation.579       * - Storage: 1 read `O(R)`, 1 mutate `O(X + R)`.580       * - One event.581       * # </weight>582       **/583      requestJudgement: AugmentedSubmittable<(regIndex: Compact<u32> | AnyNumber | Uint8Array, maxFee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;584      /**585       * Change the account associated with a registrar.586       * 587       * The dispatch origin for this call must be _Signed_ and the sender must be the account588       * of the registrar whose index is `index`.589       * 590       * - `index`: the index of the registrar whose fee is to be set.591       * - `new`: the new account ID.592       * 593       * # <weight>594       * - `O(R)`.595       * - One storage mutation `O(R)`.596       * - Benchmark: 8.823 + R * 0.32 µs (min squares analysis)597       * # </weight>598       **/599      setAccountId: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, MultiAddress]>;600      /**601       * Set the fee required for a judgement to be requested from a registrar.602       * 603       * The dispatch origin for this call must be _Signed_ and the sender must be the account604       * of the registrar whose index is `index`.605       * 606       * - `index`: the index of the registrar whose fee is to be set.607       * - `fee`: the new fee.608       * 609       * # <weight>610       * - `O(R)`.611       * - One storage mutation `O(R)`.612       * - Benchmark: 7.315 + R * 0.329 µs (min squares analysis)613       * # </weight>614       **/615      setFee: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;616      /**617       * Set the field information for a registrar.618       * 619       * The dispatch origin for this call must be _Signed_ and the sender must be the account620       * of the registrar whose index is `index`.621       * 622       * - `index`: the index of the registrar whose fee is to be set.623       * - `fields`: the fields that the registrar concerns themselves with.624       * 625       * # <weight>626       * - `O(R)`.627       * - One storage mutation `O(R)`.628       * - Benchmark: 7.464 + R * 0.325 µs (min squares analysis)629       * # </weight>630       **/631      setFields: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fields: PalletIdentityBitFlags) => SubmittableExtrinsic<ApiType>, [Compact<u32>, PalletIdentityBitFlags]>;632      /**633       * Set an account's identity information and reserve the appropriate deposit.634       * 635       * If the account already has identity information, the deposit is taken as part payment636       * for the new deposit.637       * 638       * The dispatch origin for this call must be _Signed_.639       * 640       * - `info`: The identity information.641       * 642       * Emits `IdentitySet` if successful.643       * 644       * # <weight>645       * - `O(X + X' + R)`646       * - where `X` additional-field-count (deposit-bounded and code-bounded)647       * - where `R` judgements-count (registrar-count-bounded)648       * - One balance reserve operation.649       * - One storage mutation (codec-read `O(X' + R)`, codec-write `O(X + R)`).650       * - One event.651       * # </weight>652       **/653      setIdentity: AugmentedSubmittable<(info: PalletIdentityIdentityInfo | { additional?: any; display?: any; legal?: any; web?: any; riot?: any; email?: any; pgpFingerprint?: any; image?: any; twitter?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletIdentityIdentityInfo]>;654      /**655       * Set the sub-accounts of the sender.656       * 657       * Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned658       * and an amount `SubAccountDeposit` will be reserved for each item in `subs`.659       * 660       * The dispatch origin for this call must be _Signed_ and the sender must have a registered661       * identity.662       * 663       * - `subs`: The identity's (new) sub-accounts.664       * 665       * # <weight>666       * - `O(P + S)`667       * - where `P` old-subs-count (hard- and deposit-bounded).668       * - where `S` subs-count (hard- and deposit-bounded).669       * - At most one balance operations.670       * - DB:671       * - `P + S` storage mutations (codec complexity `O(1)`)672       * - One storage read (codec complexity `O(P)`).673       * - One storage write (codec complexity `O(S)`).674       * - One storage-exists (`IdentityOf::contains_key`).675       * # </weight>676       **/677      setSubs: AugmentedSubmittable<(subs: Vec<ITuple<[AccountId32, Data]>> | ([AccountId32 | string | Uint8Array, Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[AccountId32, Data]>>]>;678      /**679       * Generic tx680       **/681      [key: string]: SubmittableExtrinsicFunction<ApiType>;682    };683    inflation: {684      /**685       * This method sets the inflation start date. Can be only called once.686       * Inflation start block can be backdated and will catch up. The method will create Treasury687       * account if it does not exist and perform the first inflation deposit.688       * 689       * # Permissions690       * 691       * * Root692       * 693       * # Arguments694       * 695       * * inflation_start_relay_block: The relay chain block at which inflation should start696       **/697      startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;698      /**699       * Generic tx700       **/701      [key: string]: SubmittableExtrinsicFunction<ApiType>;702    };703    maintenance: {704      disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;705      enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;706      /**707       * Execute a runtime call stored as a preimage.708       * 709       * `weight_bound` is the maximum weight that the caller is willing710       * to allow the extrinsic to be executed with.711       **/712      executePreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array, weightBound: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, SpWeightsWeightV2Weight]>;713      /**714       * Generic tx715       **/716      [key: string]: SubmittableExtrinsicFunction<ApiType>;717    };718    parachainInfo: {719      /**720       * Generic tx721       **/722      [key: string]: SubmittableExtrinsicFunction<ApiType>;723    };724    parachainSystem: {725      authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;726      enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;727      /**728       * Set the current validation data.729       * 730       * This should be invoked exactly once per block. It will panic at the finalization731       * phase if the call was not invoked.732       * 733       * The dispatch origin for this call must be `Inherent`734       * 735       * As a side effect, this function upgrades the current validation function736       * if the appropriate time has come.737       **/738      setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;739      sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;740      /**741       * Generic tx742       **/743      [key: string]: SubmittableExtrinsicFunction<ApiType>;744    };745    polkadotXcm: {746      /**747       * Execute an XCM message from a local, signed, origin.748       * 749       * An event is deposited indicating whether `msg` could be executed completely or only750       * partially.751       * 752       * No more than `max_weight` will be used in its attempted execution. If this is less than the753       * maximum amount of weight that the message could take to be executed, then no execution754       * attempt will be made.755       * 756       * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully757       * to completion; only that *some* of it was executed.758       **/759      execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V2: any } | { V3: any } | string | Uint8Array, maxWeight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, SpWeightsWeightV2Weight]>;760      /**761       * Set a safe XCM version (the version that XCM should be encoded with if the most recent762       * version a destination can accept is unknown).763       * 764       * - `origin`: Must be Root.765       * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.766       **/767      forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;768      /**769       * Ask a location to notify us regarding their XCM version and any changes to it.770       * 771       * - `origin`: Must be Root.772       * - `location`: The location to which we should subscribe for XCM version notifications.773       **/774      forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;775      /**776       * Require that a particular destination should no longer notify us regarding any XCM777       * version changes.778       * 779       * - `origin`: Must be Root.780       * - `location`: The location to which we are currently subscribed for XCM version781       * notifications which we no longer desire.782       **/783      forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;784      /**785       * Extoll that a particular destination can be communicated with through a particular786       * version of XCM.787       * 788       * - `origin`: Must be Root.789       * - `location`: The destination that is being described.790       * - `xcm_version`: The latest version of XCM that `location` supports.791       **/792      forceXcmVersion: AugmentedSubmittable<(location: XcmV3MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV3MultiLocation, u32]>;793      /**794       * Transfer some assets from the local chain to the sovereign account of a destination795       * chain and forward a notification XCM.796       * 797       * Fee payment on the destination side is made from the asset in the `assets` vector of798       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight799       * is needed than `weight_limit`, then the operation will fail and the assets send may be800       * at risk.801       * 802       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.803       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send804       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.805       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be806       * an `AccountId32` value.807       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the808       * `dest` side.809       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay810       * fees.811       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.812       **/813      limitedReserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V2: any } | { V3: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV3WeightLimit]>;814      /**815       * Teleport some assets from the local chain to some destination chain.816       * 817       * Fee payment on the destination side is made from the asset in the `assets` vector of818       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight819       * is needed than `weight_limit`, then the operation will fail and the assets send may be820       * at risk.821       * 822       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.823       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send824       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.825       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be826       * an `AccountId32` value.827       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the828       * `dest` side. May not be empty.829       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay830       * fees.831       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.832       **/833      limitedTeleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V2: any } | { V3: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV3WeightLimit]>;834      /**835       * Transfer some assets from the local chain to the sovereign account of a destination836       * chain and forward a notification XCM.837       * 838       * Fee payment on the destination side is made from the asset in the `assets` vector of839       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,840       * with all fees taken as needed from the asset.841       * 842       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.843       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send844       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.845       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be846       * an `AccountId32` value.847       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the848       * `dest` side.849       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay850       * fees.851       **/852      reserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V2: any } | { V3: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;853      send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, message: XcmVersionedXcm | { V2: any } | { V3: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;854      /**855       * Teleport some assets from the local chain to some destination chain.856       * 857       * Fee payment on the destination side is made from the asset in the `assets` vector of858       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,859       * with all fees taken as needed from the asset.860       * 861       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.862       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send863       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.864       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be865       * an `AccountId32` value.866       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the867       * `dest` side. May not be empty.868       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay869       * fees.870       **/871      teleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V2: any } | { V3: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;872      /**873       * Generic tx874       **/875      [key: string]: SubmittableExtrinsicFunction<ApiType>;876    };877    preimage: {878      /**879       * Register a preimage on-chain.880       * 881       * If the preimage was previously requested, no fees or deposits are taken for providing882       * the preimage. Otherwise, a deposit is taken proportional to the size of the preimage.883       **/884      notePreimage: AugmentedSubmittable<(bytes: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;885      /**886       * Request a preimage be uploaded to the chain without paying any fees or deposits.887       * 888       * If the preimage requests has already been provided on-chain, we unreserve any deposit889       * a user may have paid, and take the control of the preimage out of their hands.890       **/891      requestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;892      /**893       * Clear an unrequested preimage from the runtime storage.894       * 895       * If `len` is provided, then it will be a much cheaper operation.896       * 897       * - `hash`: The hash of the preimage to be removed from the store.898       * - `len`: The length of the preimage of `hash`.899       **/900      unnotePreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;901      /**902       * Clear a previously made request for a preimage.903       * 904       * NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`.905       **/906      unrequestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;907      /**908       * Generic tx909       **/910      [key: string]: SubmittableExtrinsicFunction<ApiType>;911    };912    session: {913      /**914       * Removes any session key(s) of the function caller.915       * 916       * This doesn't take effect until the next session.917       * 918       * The dispatch origin of this function must be Signed and the account must be either be919       * convertible to a validator ID using the chain's typical addressing system (this usually920       * means being a controller account) or directly convertible into a validator ID (which921       * usually means being a stash account).922       * 923       * ## Complexity924       * - `O(1)` in number of key types. Actual cost depends on the number of length of925       * `T::Keys::key_ids()` which is fixed.926       **/927      purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;928      /**929       * Sets the session key(s) of the function caller to `keys`.930       * Allows an account to set its session key prior to becoming a validator.931       * This doesn't take effect until the next session.932       * 933       * The dispatch origin of this function must be signed.934       * 935       * ## Complexity936       * - `O(1)`. Actual cost depends on the number of length of `T::Keys::key_ids()` which is937       * fixed.938       **/939      setKeys: AugmentedSubmittable<(keys: OpalRuntimeRuntimeCommonSessionKeys | { aura?: any } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [OpalRuntimeRuntimeCommonSessionKeys, Bytes]>;940      /**941       * Generic tx942       **/943      [key: string]: SubmittableExtrinsicFunction<ApiType>;944    };945    structure: {946      /**947       * Generic tx948       **/949      [key: string]: SubmittableExtrinsicFunction<ApiType>;950    };951    sudo: {952      /**953       * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo954       * key.955       * 956       * The dispatch origin for this call must be _Signed_.957       * 958       * ## Complexity959       * - O(1).960       **/961      setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;962      /**963       * Authenticates the sudo key and dispatches a function call with `Root` origin.964       * 965       * The dispatch origin for this call must be _Signed_.966       * 967       * ## Complexity968       * - O(1).969       **/970      sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;971      /**972       * Authenticates the sudo key and dispatches a function call with `Signed` origin from973       * a given account.974       * 975       * The dispatch origin for this call must be _Signed_.976       * 977       * ## Complexity978       * - O(1).979       **/980      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]>;981      /**982       * Authenticates the sudo key and dispatches a function call with `Root` origin.983       * This function does not check the weight of the call, and instead allows the984       * Sudo user to specify the weight of the call.985       * 986       * The dispatch origin for this call must be _Signed_.987       * 988       * ## Complexity989       * - O(1).990       **/991      sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;992      /**993       * Generic tx994       **/995      [key: string]: SubmittableExtrinsicFunction<ApiType>;996    };997    system: {998      /**999       * Kill all storage items with a key that starts with the given prefix.1000       * 1001       * **NOTE:** We rely on the Root origin to provide us the number of subkeys under1002       * the prefix we are removing to accurately calculate the weight of this function.1003       **/1004      killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;1005      /**1006       * Kill some items from storage.1007       **/1008      killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;1009      /**1010       * Make some on-chain remark.1011       * 1012       * ## Complexity1013       * - `O(1)`1014       **/1015      remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1016      /**1017       * Make some on-chain remark and emit event.1018       **/1019      remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1020      /**1021       * Set the new runtime code.1022       * 1023       * ## Complexity1024       * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`1025       **/1026      setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1027      /**1028       * Set the new runtime code without doing any checks of the given `code`.1029       * 1030       * ## Complexity1031       * - `O(C)` where `C` length of `code`1032       **/1033      setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1034      /**1035       * Set the number of pages in the WebAssembly environment's heap.1036       **/1037      setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1038      /**1039       * Set some items of storage.1040       **/1041      setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;1042      /**1043       * Generic tx1044       **/1045      [key: string]: SubmittableExtrinsicFunction<ApiType>;1046    };1047    testUtils: {1048      batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;1049      enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1050      incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1051      justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1052      setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1053      setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1054      /**1055       * Generic tx1056       **/1057      [key: string]: SubmittableExtrinsicFunction<ApiType>;1058    };1059    timestamp: {1060      /**1061       * Set the current time.1062       * 1063       * This call should be invoked exactly once per block. It will panic at the finalization1064       * phase, if this call hasn't been invoked by that time.1065       * 1066       * The timestamp should be greater than the previous one by the amount specified by1067       * `MinimumPeriod`.1068       * 1069       * The dispatch origin for this call must be `Inherent`.1070       * 1071       * ## Complexity1072       * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1073       * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1074       * `on_finalize`)1075       * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1076       **/1077      set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1078      /**1079       * Generic tx1080       **/1081      [key: string]: SubmittableExtrinsicFunction<ApiType>;1082    };1083    tokens: {1084      /**1085       * Exactly as `transfer`, except the origin must be root and the source1086       * account may be specified.1087       * 1088       * The dispatch origin for this call must be _Root_.1089       * 1090       * - `source`: The sender of the transfer.1091       * - `dest`: The recipient of the transfer.1092       * - `currency_id`: currency type.1093       * - `amount`: free balance amount to tranfer.1094       **/1095      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, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, PalletForeignAssetsAssetIds, Compact<u128>]>;1096      /**1097       * Set the balances of a given account.1098       * 1099       * This will alter `FreeBalance` and `ReservedBalance` in storage. it1100       * will also decrease the total issuance of the system1101       * (`TotalIssuance`). If the new free or reserved balance is below the1102       * existential deposit, it will reap the `AccountInfo`.1103       * 1104       * The dispatch origin for this call is `root`.1105       **/1106      setBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, newReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeignAssetsAssetIds, Compact<u128>, Compact<u128>]>;1107      /**1108       * Transfer some liquid free balance to another account.1109       * 1110       * `transfer` will set the `FreeBalance` of the sender and receiver.1111       * It will decrease the total issuance of the system by the1112       * `TransferFee`. If the sender's account is below the existential1113       * deposit as a result of the transfer, the account will be reaped.1114       * 1115       * The dispatch origin for this call must be `Signed` by the1116       * transactor.1117       * 1118       * - `dest`: The recipient of the transfer.1119       * - `currency_id`: currency type.1120       * - `amount`: free balance amount to tranfer.1121       **/1122      transfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeignAssetsAssetIds, Compact<u128>]>;1123      /**1124       * Transfer all remaining balance to the given account.1125       * 1126       * NOTE: This function only attempts to transfer _transferable_1127       * balances. This means that any locked, reserved, or existential1128       * deposits (when `keep_alive` is `true`), will not be transferred by1129       * this function. To ensure that this function results in a killed1130       * account, you might need to prepare the account by removing any1131       * reference counters, storage deposits, etc...1132       * 1133       * The dispatch origin for this call must be `Signed` by the1134       * transactor.1135       * 1136       * - `dest`: The recipient of the transfer.1137       * - `currency_id`: currency type.1138       * - `keep_alive`: A boolean to determine if the `transfer_all`1139       * operation should send all of the funds the account has, causing1140       * the sender account to be killed (false), or transfer everything1141       * except at least the existential deposit, which will guarantee to1142       * keep the sender account alive (true).1143       **/1144      transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeignAssetsAssetIds, bool]>;1145      /**1146       * Same as the [`transfer`] call, but with a check that the transfer1147       * will not kill the origin account.1148       * 1149       * 99% of the time you want [`transfer`] instead.1150       * 1151       * The dispatch origin for this call must be `Signed` by the1152       * transactor.1153       * 1154       * - `dest`: The recipient of the transfer.1155       * - `currency_id`: currency type.1156       * - `amount`: free balance amount to tranfer.1157       **/1158      transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeignAssetsAssetIds, Compact<u128>]>;1159      /**1160       * Generic tx1161       **/1162      [key: string]: SubmittableExtrinsicFunction<ApiType>;1163    };1164    treasury: {1165      /**1166       * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1167       * and the original deposit will be returned.1168       * 1169       * May only be called from `T::ApproveOrigin`.1170       * 1171       * ## Complexity1172       * - O(1).1173       **/1174      approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1175      /**1176       * Put forward a suggestion for spending. A deposit proportional to the value1177       * is reserved and slashed if the proposal is rejected. It is returned once the1178       * proposal is awarded.1179       * 1180       * ## Complexity1181       * - O(1)1182       **/1183      proposeSpend: AugmentedSubmittable<(value: Compact<u128> | AnyNumber | Uint8Array, beneficiary: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>, MultiAddress]>;1184      /**1185       * Reject a proposed spend. The original deposit will be slashed.1186       * 1187       * May only be called from `T::RejectOrigin`.1188       * 1189       * ## Complexity1190       * - O(1)1191       **/1192      rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1193      /**1194       * Force a previously approved proposal to be removed from the approval queue.1195       * The original deposit will no longer be returned.1196       * 1197       * May only be called from `T::RejectOrigin`.1198       * - `proposal_id`: The index of a proposal1199       * 1200       * ## Complexity1201       * - O(A) where `A` is the number of approvals1202       * 1203       * Errors:1204       * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1205       * i.e., the proposal has not been approved. This could also mean the proposal does not1206       * exist altogether, thus there is no way it would have been approved in the first place.1207       **/1208      removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1209      /**1210       * Propose and approve a spend of treasury funds.1211       * 1212       * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1213       * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1214       * - `beneficiary`: The destination account for the transfer.1215       * 1216       * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1217       * beneficiary.1218       **/1219      spend: AugmentedSubmittable<(amount: Compact<u128> | AnyNumber | Uint8Array, beneficiary: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>, MultiAddress]>;1220      /**1221       * Generic tx1222       **/1223      [key: string]: SubmittableExtrinsicFunction<ApiType>;1224    };1225    unique: {1226      /**1227       * Add an admin to a collection.1228       * 1229       * NFT Collection can be controlled by multiple admin addresses1230       * (some which can also be servers, for example). Admins can issue1231       * and burn NFTs, as well as add and remove other admins,1232       * but cannot change NFT or Collection ownership.1233       * 1234       * # Permissions1235       * 1236       * * Collection owner1237       * * Collection admin1238       * 1239       * # Arguments1240       * 1241       * * `collection_id`: ID of the Collection to add an admin for.1242       * * `new_admin`: Address of new admin to add.1243       **/1244      addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1245      /**1246       * Add an address to allow list.1247       * 1248       * # Permissions1249       * 1250       * * Collection owner1251       * * Collection admin1252       * 1253       * # Arguments1254       * 1255       * * `collection_id`: ID of the modified collection.1256       * * `address`: ID of the address to be added to the allowlist.1257       **/1258      addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1259      /**1260       * Allow a non-permissioned address to transfer or burn an item.1261       * 1262       * # Permissions1263       * 1264       * * Collection owner1265       * * Collection admin1266       * * Current item owner1267       * 1268       * # Arguments1269       * 1270       * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1271       * * `collection_id`: ID of the collection the item belongs to.1272       * * `item_id`: ID of the item transactions on which are now approved.1273       * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1274       * Set to 0 to revoke the approval.1275       **/1276      approve: AugmentedSubmittable<(spender: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr, u32, u32, u128]>;1277      /**1278       * Allow a non-permissioned address to transfer or burn an item from owner's eth mirror.1279       * 1280       * # Permissions1281       * 1282       * * Collection owner1283       * * Collection admin1284       * * Current item owner1285       * 1286       * # Arguments1287       * 1288       * * `from`: Owner's account eth mirror1289       * * `to`: Account to be approved to make specific transactions on non-owned tokens.1290       * * `collection_id`: ID of the collection the item belongs to.1291       * * `item_id`: ID of the item transactions on which are now approved.1292       * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1293       * Set to 0 to revoke the approval.1294       **/1295      approveFrom: AugmentedSubmittable<(from: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, to: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, u32, u32, u128]>;1296      /**1297       * Destroy a token on behalf of the owner as a non-owner account.1298       * 1299       * See also: [`approve`][`Pallet::approve`].1300       * 1301       * After this method executes, one approval is removed from the total so that1302       * the approved address will not be able to transfer this item again from this owner.1303       * 1304       * # Permissions1305       * 1306       * * Collection owner1307       * * Collection admin1308       * * Current token owner1309       * * Address approved by current item owner1310       * 1311       * # Arguments1312       * 1313       * * `from`: The owner of the burning item.1314       * * `collection_id`: ID of the collection to which the item belongs.1315       * * `item_id`: ID of item to burn.1316       * * `value`: Number of pieces to burn.1317       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1318       * * Fungible Mode: The desired number of pieces to burn.1319       * * Re-Fungible Mode: The desired number of pieces to burn.1320       **/1321      burnFrom: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, from: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, u32, u128]>;1322      /**1323       * Destroy an item.1324       * 1325       * # Permissions1326       * 1327       * * Collection owner1328       * * Collection admin1329       * * Current item owner1330       * 1331       * # Arguments1332       * 1333       * * `collection_id`: ID of the collection to which the item belongs.1334       * * `item_id`: ID of item to burn.1335       * * `value`: Number of pieces of the item to destroy.1336       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1337       * * Fungible Mode: The desired number of pieces to burn.1338       * * Re-Fungible Mode: The desired number of pieces to burn.1339       **/1340      burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1341      /**1342       * Change the owner of the collection.1343       * 1344       * # Permissions1345       * 1346       * * Collection owner1347       * 1348       * # Arguments1349       * 1350       * * `collection_id`: ID of the modified collection.1351       * * `new_owner`: ID of the account that will become the owner.1352       **/1353      changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1354      /**1355       * Confirm own sponsorship of a collection, becoming the sponsor.1356       * 1357       * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1358       * Sponsor can pay the fees of a transaction instead of the sender,1359       * but only within specified limits.1360       * 1361       * # Permissions1362       * 1363       * * Sponsor-to-be1364       * 1365       * # Arguments1366       * 1367       * * `collection_id`: ID of the collection with the pending sponsor.1368       **/1369      confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1370      /**1371       * Create a collection of tokens.1372       * 1373       * Each Token may have multiple properties encoded as an array of bytes1374       * of certain length. The initial owner of the collection is set1375       * to the address that signed the transaction and can be changed later.1376       * 1377       * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1378       * 1379       * # Permissions1380       * 1381       * * Anyone - becomes the owner of the new collection.1382       * 1383       * # Arguments1384       * 1385       * * `collection_name`: Wide-character string with collection name1386       * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1387       * * `collection_description`: Wide-character string with collection description1388       * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1389       * * `token_prefix`: Byte string containing the token prefix to mark a collection1390       * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1391       * * `mode`: Type of items stored in the collection and type dependent data.1392       * 1393       * returns collection ID1394       * 1395       * Deprecated: `create_collection_ex` is more up-to-date and advanced, prefer it instead.1396       **/1397      createCollection: AugmentedSubmittable<(collectionName: Vec<u16> | (u16 | AnyNumber | Uint8Array)[], collectionDescription: Vec<u16> | (u16 | AnyNumber | Uint8Array)[], tokenPrefix: Bytes | string | Uint8Array, mode: UpDataStructsCollectionMode | { NFT: any } | { Fungible: any } | { ReFungible: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<u16>, Vec<u16>, Bytes, UpDataStructsCollectionMode]>;1398      /**1399       * Create a collection with explicit parameters.1400       * 1401       * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1402       * 1403       * # Permissions1404       * 1405       * * Anyone - becomes the owner of the new collection.1406       * 1407       * # Arguments1408       * 1409       * * `data`: Explicit data of a collection used for its creation.1410       **/1411      createCollectionEx: AugmentedSubmittable<(data: UpDataStructsCreateCollectionData | { mode?: any; access?: any; name?: any; description?: any; tokenPrefix?: any; pendingSponsor?: any; limits?: any; permissions?: any; tokenPropertyPermissions?: any; properties?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [UpDataStructsCreateCollectionData]>;1412      /**1413       * Mint an item within a collection.1414       * 1415       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1416       * 1417       * # Permissions1418       * 1419       * * Collection owner1420       * * Collection admin1421       * * Anyone if1422       * * Allow List is enabled, and1423       * * Address is added to allow list, and1424       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1425       * 1426       * # Arguments1427       * 1428       * * `collection_id`: ID of the collection to which an item would belong.1429       * * `owner`: Address of the initial owner of the item.1430       * * `data`: Token data describing the item to store on chain.1431       **/1432      createItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, owner: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, data: UpDataStructsCreateItemData | { NFT: any } | { Fungible: any } | { ReFungible: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, UpDataStructsCreateItemData]>;1433      /**1434       * Create multiple items within a collection.1435       * 1436       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1437       * 1438       * # Permissions1439       * 1440       * * Collection owner1441       * * Collection admin1442       * * Anyone if1443       * * Allow List is enabled, and1444       * * Address is added to the allow list, and1445       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1446       * 1447       * # Arguments1448       * 1449       * * `collection_id`: ID of the collection to which the tokens would belong.1450       * * `owner`: Address of the initial owner of the tokens.1451       * * `items_data`: Vector of data describing each item to be created.1452       **/1453      createMultipleItems: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, owner: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, itemsData: Vec<UpDataStructsCreateItemData> | (UpDataStructsCreateItemData | { NFT: any } | { Fungible: any } | { ReFungible: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, Vec<UpDataStructsCreateItemData>]>;1454      /**1455       * Create multiple items within a collection with explicitly specified initial parameters.1456       * 1457       * # Permissions1458       * 1459       * * Collection owner1460       * * Collection admin1461       * * Anyone if1462       * * Allow List is enabled, and1463       * * Address is added to allow list, and1464       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1465       * 1466       * # Arguments1467       * 1468       * * `collection_id`: ID of the collection to which the tokens would belong.1469       * * `data`: Explicit item creation data.1470       **/1471      createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1472      /**1473       * Delete specified collection properties.1474       * 1475       * # Permissions1476       * 1477       * * Collection Owner1478       * * Collection Admin1479       * 1480       * # Arguments1481       * 1482       * * `collection_id`: ID of the modified collection.1483       * * `property_keys`: Vector of keys of the properties to be deleted.1484       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1485       **/1486      deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1487      /**1488       * Delete specified token properties. Currently properties only work with NFTs.1489       * 1490       * # Permissions1491       * 1492       * * Depends on collection's token property permissions and specified property mutability:1493       * * Collection owner1494       * * Collection admin1495       * * Token owner1496       * 1497       * # Arguments1498       * 1499       * * `collection_id`: ID of the collection to which the token belongs.1500       * * `token_id`: ID of the modified token.1501       * * `property_keys`: Vector of keys of the properties to be deleted.1502       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1503       **/1504      deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1505      /**1506       * Destroy a collection if no tokens exist within.1507       * 1508       * # Permissions1509       * 1510       * * Collection owner1511       * 1512       * # Arguments1513       * 1514       * * `collection_id`: Collection to destroy.1515       **/1516      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1517      /**1518       * Repairs a collection if the data was somehow corrupted.1519       * 1520       * # Arguments1521       * 1522       * * `collection_id`: ID of the collection to repair.1523       **/1524      forceRepairCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1525      /**1526       * Repairs a token if the data was somehow corrupted.1527       * 1528       * # Arguments1529       * 1530       * * `collection_id`: ID of the collection the item belongs to.1531       * * `item_id`: ID of the item.1532       **/1533      forceRepairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1534      /**1535       * Remove admin of a collection.1536       * 1537       * An admin address can remove itself. List of admins may become empty,1538       * in which case only Collection Owner will be able to add an Admin.1539       * 1540       * # Permissions1541       * 1542       * * Collection owner1543       * * Collection admin1544       * 1545       * # Arguments1546       * 1547       * * `collection_id`: ID of the collection to remove the admin for.1548       * * `account_id`: Address of the admin to remove.1549       **/1550      removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1551      /**1552       * Remove a collection's a sponsor, making everyone pay for their own transactions.1553       * 1554       * # Permissions1555       * 1556       * * Collection owner1557       * 1558       * # Arguments1559       * 1560       * * `collection_id`: ID of the collection with the sponsor to remove.1561       **/1562      removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1563      /**1564       * Remove an address from allow list.1565       * 1566       * # Permissions1567       * 1568       * * Collection owner1569       * * Collection admin1570       * 1571       * # Arguments1572       * 1573       * * `collection_id`: ID of the modified collection.1574       * * `address`: ID of the address to be removed from the allowlist.1575       **/1576      removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1577      /**1578       * Re-partition a refungible token, while owning all of its parts/pieces.1579       * 1580       * # Permissions1581       * 1582       * * Token owner (must own every part)1583       * 1584       * # Arguments1585       * 1586       * * `collection_id`: ID of the collection the RFT belongs to.1587       * * `token_id`: ID of the RFT.1588       * * `amount`: New number of parts/pieces into which the token shall be partitioned.1589       **/1590      repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1591      /**1592       * Sets or unsets the approval of a given operator.1593       * 1594       * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1595       * 1596       * # Arguments1597       * 1598       * * `owner`: Token owner1599       * * `operator`: Operator1600       * * `approve`: Should operator status be granted or revoked?1601       **/1602      setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1603      /**1604       * Set specific limits of a collection. Empty, or None fields mean chain default.1605       * 1606       * # Permissions1607       * 1608       * * Collection owner1609       * * Collection admin1610       * 1611       * # Arguments1612       * 1613       * * `collection_id`: ID of the modified collection.1614       * * `new_limit`: New limits of the collection. Fields that are not set (None)1615       * will not overwrite the old ones.1616       **/1617      setCollectionLimits: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newLimit: UpDataStructsCollectionLimits | { accountTokenOwnershipLimit?: any; sponsoredDataSize?: any; sponsoredDataRateLimit?: any; tokenLimit?: any; sponsorTransferTimeout?: any; sponsorApproveTimeout?: any; ownerCanTransfer?: any; ownerCanDestroy?: any; transfersEnabled?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionLimits]>;1618      /**1619       * Set specific permissions of a collection. Empty, or None fields mean chain default.1620       * 1621       * # Permissions1622       * 1623       * * Collection owner1624       * * Collection admin1625       * 1626       * # Arguments1627       * 1628       * * `collection_id`: ID of the modified collection.1629       * * `new_permission`: New permissions of the collection. Fields that are not set (None)1630       * will not overwrite the old ones.1631       **/1632      setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1633      /**1634       * Add or change collection properties.1635       * 1636       * # Permissions1637       * 1638       * * Collection owner1639       * * Collection admin1640       * 1641       * # Arguments1642       * 1643       * * `collection_id`: ID of the modified collection.1644       * * `properties`: Vector of key-value pairs stored as the collection's metadata.1645       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1646       **/1647      setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1648      /**1649       * Set (invite) a new collection sponsor.1650       * 1651       * If successful, confirmation from the sponsor-to-be will be pending.1652       * 1653       * # Permissions1654       * 1655       * * Collection owner1656       * * Collection admin1657       * 1658       * # Arguments1659       * 1660       * * `collection_id`: ID of the modified collection.1661       * * `new_sponsor`: ID of the account of the sponsor-to-be.1662       **/1663      setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1664      /**1665       * Add or change token properties according to collection's permissions.1666       * Currently properties only work with NFTs.1667       * 1668       * # Permissions1669       * 1670       * * Depends on collection's token property permissions and specified property mutability:1671       * * Collection owner1672       * * Collection admin1673       * * Token owner1674       * 1675       * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1676       * 1677       * # Arguments1678       * 1679       * * `collection_id: ID of the collection to which the token belongs.1680       * * `token_id`: ID of the modified token.1681       * * `properties`: Vector of key-value pairs stored as the token's metadata.1682       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1683       **/1684      setTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<UpDataStructsProperty>]>;1685      /**1686       * Add or change token property permissions of a collection.1687       * 1688       * Without a permission for a particular key, a property with that key1689       * cannot be created in a token.1690       * 1691       * # Permissions1692       * 1693       * * Collection owner1694       * * Collection admin1695       * 1696       * # Arguments1697       * 1698       * * `collection_id`: ID of the modified collection.1699       * * `property_permissions`: Vector of permissions for property keys.1700       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1701       **/1702      setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1703      /**1704       * Completely allow or disallow transfers for a particular collection.1705       * 1706       * # Permissions1707       * 1708       * * Collection owner1709       * 1710       * # Arguments1711       * 1712       * * `collection_id`: ID of the collection.1713       * * `value`: New value of the flag, are transfers allowed?1714       **/1715      setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1716      /**1717       * Change ownership of the token.1718       * 1719       * # Permissions1720       * 1721       * * Collection owner1722       * * Collection admin1723       * * Current token owner1724       * 1725       * # Arguments1726       * 1727       * * `recipient`: Address of token recipient.1728       * * `collection_id`: ID of the collection the item belongs to.1729       * * `item_id`: ID of the item.1730       * * Non-Fungible Mode: Required.1731       * * Fungible Mode: Ignored.1732       * * Re-Fungible Mode: Required.1733       * 1734       * * `value`: Amount to transfer.1735       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1736       * * Fungible Mode: The desired number of pieces to transfer.1737       * * Re-Fungible Mode: The desired number of pieces to transfer.1738       **/1739      transfer: AugmentedSubmittable<(recipient: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr, u32, u32, u128]>;1740      /**1741       * Change ownership of an item on behalf of the owner as a non-owner account.1742       * 1743       * See the [`approve`][`Pallet::approve`] method for additional information.1744       * 1745       * After this method executes, one approval is removed from the total so that1746       * the approved address will not be able to transfer this item again from this owner.1747       * 1748       * # Permissions1749       * 1750       * * Collection owner1751       * * Collection admin1752       * * Current item owner1753       * * Address approved by current item owner1754       * 1755       * # Arguments1756       * 1757       * * `from`: Address that currently owns the token.1758       * * `recipient`: Address of the new token-owner-to-be.1759       * * `collection_id`: ID of the collection the item.1760       * * `item_id`: ID of the item to be transferred.1761       * * `value`: Amount to transfer.1762       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1763       * * Fungible Mode: The desired number of pieces to transfer.1764       * * Re-Fungible Mode: The desired number of pieces to transfer.1765       **/1766      transferFrom: AugmentedSubmittable<(from: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, recipient: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, u32, u32, u128]>;1767      /**1768       * Generic tx1769       **/1770      [key: string]: SubmittableExtrinsicFunction<ApiType>;1771    };1772    vesting: {1773      claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1774      claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1775      updateVestingSchedules: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, vestingSchedules: Vec<OrmlVestingVestingSchedule> | (OrmlVestingVestingSchedule | { start?: any; period?: any; periodCount?: any; perPeriod?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [MultiAddress, Vec<OrmlVestingVestingSchedule>]>;1776      vestedTransfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, schedule: OrmlVestingVestingSchedule | { start?: any; period?: any; periodCount?: any; perPeriod?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, OrmlVestingVestingSchedule]>;1777      /**1778       * Generic tx1779       **/1780      [key: string]: SubmittableExtrinsicFunction<ApiType>;1781    };1782    xcmpQueue: {1783      /**1784       * Resumes all XCM executions for the XCMP queue.1785       * 1786       * Note that this function doesn't change the status of the in/out bound channels.1787       * 1788       * - `origin`: Must pass `ControllerOrigin`.1789       **/1790      resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1791      /**1792       * Services a single overweight XCM.1793       * 1794       * - `origin`: Must pass `ExecuteOverweightOrigin`.1795       * - `index`: The index of the overweight XCM to service1796       * - `weight_limit`: The amount of weight that XCM execution may take.1797       * 1798       * Errors:1799       * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1800       * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1801       * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1802       * 1803       * Events:1804       * - `OverweightServiced`: On success.1805       **/1806      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, SpWeightsWeightV2Weight]>;1807      /**1808       * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1809       * 1810       * - `origin`: Must pass `ControllerOrigin`.1811       **/1812      suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1813      /**1814       * Overwrites the number of pages of messages which must be in the queue after which we drop any further1815       * messages from the channel.1816       * 1817       * - `origin`: Must pass `Root`.1818       * - `new`: Desired value for `QueueConfigData.drop_threshold`1819       **/1820      updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1821      /**1822       * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1823       * message sending may recommence after it has been suspended.1824       * 1825       * - `origin`: Must pass `Root`.1826       * - `new`: Desired value for `QueueConfigData.resume_threshold`1827       **/1828      updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1829      /**1830       * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1831       * suspend their sending.1832       * 1833       * - `origin`: Must pass `Root`.1834       * - `new`: Desired value for `QueueConfigData.suspend_value`1835       **/1836      updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1837      /**1838       * Overwrites the amount of remaining weight under which we stop processing messages.1839       * 1840       * - `origin`: Must pass `Root`.1841       * - `new`: Desired value for `QueueConfigData.threshold_weight`1842       **/1843      updateThresholdWeight: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;1844      /**1845       * Overwrites the speed to which the available weight approaches the maximum weight.1846       * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1847       * 1848       * - `origin`: Must pass `Root`.1849       * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1850       **/1851      updateWeightRestrictDecay: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;1852      /**1853       * Overwrite the maximum amount of weight any individual message may consume.1854       * Messages above this weight go into the overweight queue and may only be serviced explicitly.1855       * 1856       * - `origin`: Must pass `Root`.1857       * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1858       **/1859      updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;1860      /**1861       * Generic tx1862       **/1863      [key: string]: SubmittableExtrinsicFunction<ApiType>;1864    };1865    xTokens: {1866      /**1867       * Transfer native currencies.1868       * 1869       * `dest_weight_limit` is the weight for XCM execution on the dest1870       * chain, and it would be charged from the transferred assets. If set1871       * below requirements, the execution may fail and assets wouldn't be1872       * received.1873       * 1874       * It's a no-op if any error on local XCM execution or message sending.1875       * Note sending assets out per se doesn't guarantee they would be1876       * received. Receiving depends on if the XCM message could be delivered1877       * by the network, and if the receiving chain would handle1878       * messages correctly.1879       **/1880      transfer: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, XcmVersionedMultiLocation, XcmV3WeightLimit]>;1881      /**1882       * Transfer `MultiAsset`.1883       * 1884       * `dest_weight_limit` is the weight for XCM execution on the dest1885       * chain, and it would be charged from the transferred assets. If set1886       * below requirements, the execution may fail and assets wouldn't be1887       * received.1888       * 1889       * It's a no-op if any error on local XCM execution or message sending.1890       * Note sending assets out per se doesn't guarantee they would be1891       * received. Receiving depends on if the XCM message could be delivered1892       * by the network, and if the receiving chain would handle1893       * messages correctly.1894       **/1895      transferMultiasset: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V2: any } | { V3: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiLocation, XcmV3WeightLimit]>;1896      /**1897       * Transfer several `MultiAsset` specifying the item to be used as fee1898       * 1899       * `dest_weight_limit` is the weight for XCM execution on the dest1900       * chain, and it would be charged from the transferred assets. If set1901       * below requirements, the execution may fail and assets wouldn't be1902       * received.1903       * 1904       * `fee_item` is index of the MultiAssets that we want to use for1905       * payment1906       * 1907       * It's a no-op if any error on local XCM execution or message sending.1908       * Note sending assets out per se doesn't guarantee they would be1909       * received. Receiving depends on if the XCM message could be delivered1910       * by the network, and if the receiving chain would handle1911       * messages correctly.1912       **/1913      transferMultiassets: AugmentedSubmittable<(assets: XcmVersionedMultiAssets | { V2: any } | { V3: any } | string | Uint8Array, feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAssets, u32, XcmVersionedMultiLocation, XcmV3WeightLimit]>;1914      /**1915       * Transfer `MultiAsset` specifying the fee and amount as separate.1916       * 1917       * `dest_weight_limit` is the weight for XCM execution on the dest1918       * chain, and it would be charged from the transferred assets. If set1919       * below requirements, the execution may fail and assets wouldn't be1920       * received.1921       * 1922       * `fee` is the multiasset to be spent to pay for execution in1923       * destination chain. Both fee and amount will be subtracted form the1924       * callers balance For now we only accept fee and asset having the same1925       * `MultiLocation` id.1926       * 1927       * If `fee` is not high enough to cover for the execution costs in the1928       * destination chain, then the assets will be trapped in the1929       * destination chain1930       * 1931       * It's a no-op if any error on local XCM execution or message sending.1932       * Note sending assets out per se doesn't guarantee they would be1933       * received. Receiving depends on if the XCM message could be delivered1934       * by the network, and if the receiving chain would handle1935       * messages correctly.1936       **/1937      transferMultiassetWithFee: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V2: any } | { V3: any } | string | Uint8Array, fee: XcmVersionedMultiAsset | { V2: any } | { V3: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiAsset, XcmVersionedMultiLocation, XcmV3WeightLimit]>;1938      /**1939       * Transfer several currencies specifying the item to be used as fee1940       * 1941       * `dest_weight_limit` is the weight for XCM execution on the dest1942       * chain, and it would be charged from the transferred assets. If set1943       * below requirements, the execution may fail and assets wouldn't be1944       * received.1945       * 1946       * `fee_item` is index of the currencies tuple that we want to use for1947       * payment1948       * 1949       * It's a no-op if any error on local XCM execution or message sending.1950       * Note sending assets out per se doesn't guarantee they would be1951       * received. Receiving depends on if the XCM message could be delivered1952       * by the network, and if the receiving chain would handle1953       * messages correctly.1954       **/1955      transferMulticurrencies: AugmentedSubmittable<(currencies: Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>> | ([PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, u128 | AnyNumber | Uint8Array])[], feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>>, u32, XcmVersionedMultiLocation, XcmV3WeightLimit]>;1956      /**1957       * Transfer native currencies specifying the fee and amount as1958       * separate.1959       * 1960       * `dest_weight_limit` is the weight for XCM execution on the dest1961       * chain, and it would be charged from the transferred assets. If set1962       * below requirements, the execution may fail and assets wouldn't be1963       * received.1964       * 1965       * `fee` is the amount to be spent to pay for execution in destination1966       * chain. Both fee and amount will be subtracted form the callers1967       * balance.1968       * 1969       * If `fee` is not high enough to cover for the execution costs in the1970       * destination chain, then the assets will be trapped in the1971       * destination chain1972       * 1973       * It's a no-op if any error on local XCM execution or message sending.1974       * Note sending assets out per se doesn't guarantee they would be1975       * received. Receiving depends on if the XCM message could be delivered1976       * by the network, and if the receiving chain would handle1977       * messages correctly.1978       **/1979      transferWithFee: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, fee: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, u128, XcmVersionedMultiLocation, XcmV3WeightLimit]>;1980      /**1981       * Generic tx1982       **/1983      [key: string]: SubmittableExtrinsicFunction<ApiType>;1984    };1985  } // AugmentedSubmittables1986} // declare module