`5e5eea47bafd`

source

tests/src/interfaces/augment-api-tx.ts99.9 KiBsource history
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 { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';10import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';11import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill, Weight } from '@polkadot/types/interfaces/runtime';12import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';1314export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;15export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;16export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;1718declare module '@polkadot/api-base/types/submittable' {19  interface AugmentedSubmittables<ApiType extends ApiTypes> {20    appPromotion: {21      /**22       * Recalculates interest for the specified number of stakers.23       * If all stakers are not recalculated, the next call of the extrinsic24       * will continue the recalculation, from those stakers for whom this25       * was not perform in last call.26       * 27       * # Permissions28       * 29       * * Pallet admin30       * 31       * # Arguments32       * 33       * * `stakers_number`: the number of stakers for which recalculation will be performed34       **/35      payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;36      /**37       * Sets an address as the the admin.38       * 39       * # Permissions40       * 41       * * Sudo42       * 43       * # Arguments44       * 45       * * `admin`: account of the new admin.46       **/47      setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;48      /**49       * Sets the pallet to be the sponsor for the collection.50       * 51       * # Permissions52       * 53       * * Pallet admin54       * 55       * # Arguments56       * 57       * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`58       **/59      sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;60      /**61       * Sets the pallet to be the sponsor for the contract.62       * 63       * # Permissions64       * 65       * * Pallet admin66       * 67       * # Arguments68       * 69       * * `contract_id`: the contract address that will be sponsored by `pallet_id`70       **/71      sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;72      /**73       * Stakes the amount of native tokens.74       * Sets `amount` to the locked state.75       * The maximum number of stakes for a staker is 10.76       * 77       * # Arguments78       * 79       * * `amount`: in native tokens.80       **/81      stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;82      /**83       * Removes the pallet as the sponsor for the collection.84       * Returns [`NoPermission`][`Error::NoPermission`]85       * if the pallet wasn't the sponsor.86       * 87       * # Permissions88       * 89       * * Pallet admin90       * 91       * # Arguments92       * 93       * * `collection_id`: ID of the collection that is sponsored by `pallet_id`94       **/95      stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;96      /**97       * Removes the pallet as the sponsor for the contract.98       * Returns [`NoPermission`][`Error::NoPermission`]99       * if the pallet wasn't the sponsor.100       * 101       * # Permissions102       * 103       * * Pallet admin104       * 105       * # Arguments106       * 107       * * `contract_id`: the contract address that is sponsored by `pallet_id`108       **/109      stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;110      /**111       * Unstakes all stakes.112       * Moves the sum of all stakes to the `reserved` state.113       * After the end of `PendingInterval` this sum becomes completely114       * free for further use.115       **/116      unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;117      /**118       * Generic tx119       **/120      [key: string]: SubmittableExtrinsicFunction<ApiType>;121    };122    balances: {123      /**124       * Exactly as `transfer`, except the origin must be root and the source account may be125       * specified.126       * # <weight>127       * - Same as transfer, but additional read and write because the source account is not128       * assumed to be in the overlay.129       * # </weight>130       **/131      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>]>;132      /**133       * Unreserve some balance from a user by force.134       * 135       * Can only be called by ROOT.136       **/137      forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;138      /**139       * Set the balances of a given account.140       * 141       * This will alter `FreeBalance` and `ReservedBalance` in storage. it will142       * also alter the total issuance of the system (`TotalIssuance`) appropriately.143       * If the new free or reserved balance is below the existential deposit,144       * it will reset the account nonce (`frame_system::AccountNonce`).145       * 146       * The dispatch origin for this call is `root`.147       **/148      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>]>;149      /**150       * Transfer some liquid free balance to another account.151       * 152       * `transfer` will set the `FreeBalance` of the sender and receiver.153       * If the sender's account is below the existential deposit as a result154       * of the transfer, the account will be reaped.155       * 156       * The dispatch origin for this call must be `Signed` by the transactor.157       * 158       * # <weight>159       * - Dependent on arguments but not critical, given proper implementations for input config160       * types. See related functions below.161       * - It contains a limited number of reads and writes internally and no complex162       * computation.163       * 164       * Related functions:165       * 166       * - `ensure_can_withdraw` is always called internally but has a bounded complexity.167       * - Transferring balances to accounts that did not exist before will cause168       * `T::OnNewAccount::on_new_account` to be called.169       * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.170       * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check171       * that the transfer will not kill the origin account.172       * ---------------------------------173       * - Origin account is already in memory, so no DB operations for them.174       * # </weight>175       **/176      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>]>;177      /**178       * Transfer the entire transferable balance from the caller account.179       * 180       * NOTE: This function only attempts to transfer _transferable_ balances. This means that181       * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be182       * transferred by this function. To ensure that this function results in a killed account,183       * you might need to prepare the account by removing any reference counters, storage184       * deposits, etc...185       * 186       * The dispatch origin of this call must be Signed.187       * 188       * - `dest`: The recipient of the transfer.189       * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all190       * of the funds the account has, causing the sender account to be killed (false), or191       * transfer everything except at least the existential deposit, which will guarantee to192       * keep the sender account alive (true). # <weight>193       * - O(1). Just like transfer, but reading the user's transferable balance first.194       * #</weight>195       **/196      transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;197      /**198       * Same as the [`transfer`] call, but with a check that the transfer will not kill the199       * origin account.200       * 201       * 99% of the time you want [`transfer`] instead.202       * 203       * [`transfer`]: struct.Pallet.html#method.transfer204       **/205      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>]>;206      /**207       * Generic tx208       **/209      [key: string]: SubmittableExtrinsicFunction<ApiType>;210    };211    charging: {212      /**213       * Generic tx214       **/215      [key: string]: SubmittableExtrinsicFunction<ApiType>;216    };217    configuration: {218      setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;219      setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;220      /**221       * Generic tx222       **/223      [key: string]: SubmittableExtrinsicFunction<ApiType>;224    };225    cumulusXcm: {226      /**227       * Generic tx228       **/229      [key: string]: SubmittableExtrinsicFunction<ApiType>;230    };231    dmpQueue: {232      /**233       * Service a single overweight message.234       * 235       * - `origin`: Must pass `ExecuteOverweightOrigin`.236       * - `index`: The index of the overweight message to service.237       * - `weight_limit`: The amount of weight that message execution may take.238       * 239       * Errors:240       * - `Unknown`: Message of `index` is unknown.241       * - `OverLimit`: Message execution may use greater than `weight_limit`.242       * 243       * Events:244       * - `OverweightServiced`: On success.245       **/246      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, Weight]>;247      /**248       * Generic tx249       **/250      [key: string]: SubmittableExtrinsicFunction<ApiType>;251    };252    ethereum: {253      /**254       * Transact an Ethereum transaction.255       **/256      transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;257      /**258       * Generic tx259       **/260      [key: string]: SubmittableExtrinsicFunction<ApiType>;261    };262    evm: {263      /**264       * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.265       **/266      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>]>>]>;267      /**268       * Issue an EVM create operation. This is similar to a contract creation transaction in269       * Ethereum.270       **/271      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>]>>]>;272      /**273       * Issue an EVM create2 operation.274       **/275      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>]>>]>;276      /**277       * Withdraw balance from EVM into currency/balances pallet.278       **/279      withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;280      /**281       * Generic tx282       **/283      [key: string]: SubmittableExtrinsicFunction<ApiType>;284    };285    evmMigration: {286      /**287       * Start contract migration, inserts contract stub at target address,288       * and marks account as pending, allowing to insert storage289       **/290      begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;291      /**292       * Finish contract migration, allows it to be called.293       * It is not possible to alter contract storage via [`Self::set_data`]294       * after this call.295       **/296      finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;297      /**298       * Insert items into contract storage, this method can be called299       * multiple times300       **/301      setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;302      /**303       * Generic tx304       **/305      [key: string]: SubmittableExtrinsicFunction<ApiType>;306    };307    foreignAssets: {308      registerForeignAsset: AugmentedSubmittable<(owner: AccountId32 | string | Uint8Array, location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;309      updateForeignAsset: AugmentedSubmittable<(foreignAssetId: u32 | AnyNumber | Uint8Array, location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;310      /**311       * Generic tx312       **/313      [key: string]: SubmittableExtrinsicFunction<ApiType>;314    };315    inflation: {316      /**317       * This method sets the inflation start date. Can be only called once.318       * Inflation start block can be backdated and will catch up. The method will create Treasury319       * account if it does not exist and perform the first inflation deposit.320       * 321       * # Permissions322       * 323       * * Root324       * 325       * # Arguments326       * 327       * * inflation_start_relay_block: The relay chain block at which inflation should start328       **/329      startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;330      /**331       * Generic tx332       **/333      [key: string]: SubmittableExtrinsicFunction<ApiType>;334    };335    parachainSystem: {336      authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;337      enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;338      /**339       * Set the current validation data.340       * 341       * This should be invoked exactly once per block. It will panic at the finalization342       * phase if the call was not invoked.343       * 344       * The dispatch origin for this call must be `Inherent`345       * 346       * As a side effect, this function upgrades the current validation function347       * if the appropriate time has come.348       **/349      setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;350      sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;351      /**352       * Generic tx353       **/354      [key: string]: SubmittableExtrinsicFunction<ApiType>;355    };356    polkadotXcm: {357      /**358       * Execute an XCM message from a local, signed, origin.359       * 360       * An event is deposited indicating whether `msg` could be executed completely or only361       * partially.362       * 363       * No more than `max_weight` will be used in its attempted execution. If this is less than the364       * maximum amount of weight that the message could take to be executed, then no execution365       * attempt will be made.366       * 367       * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully368       * to completion; only that *some* of it was executed.369       **/370      execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, Weight]>;371      /**372       * Set a safe XCM version (the version that XCM should be encoded with if the most recent373       * version a destination can accept is unknown).374       * 375       * - `origin`: Must be Root.376       * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.377       **/378      forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;379      /**380       * Ask a location to notify us regarding their XCM version and any changes to it.381       * 382       * - `origin`: Must be Root.383       * - `location`: The location to which we should subscribe for XCM version notifications.384       **/385      forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;386      /**387       * Require that a particular destination should no longer notify us regarding any XCM388       * version changes.389       * 390       * - `origin`: Must be Root.391       * - `location`: The location to which we are currently subscribed for XCM version392       * notifications which we no longer desire.393       **/394      forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;395      /**396       * Extoll that a particular destination can be communicated with through a particular397       * version of XCM.398       * 399       * - `origin`: Must be Root.400       * - `location`: The destination that is being described.401       * - `xcm_version`: The latest version of XCM that `location` supports.402       **/403      forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;404      /**405       * Transfer some assets from the local chain to the sovereign account of a destination406       * chain and forward a notification XCM.407       * 408       * Fee payment on the destination side is made from the asset in the `assets` vector of409       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight410       * is needed than `weight_limit`, then the operation will fail and the assets send may be411       * at risk.412       * 413       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.414       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send415       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.416       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be417       * an `AccountId32` value.418       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the419       * `dest` side.420       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay421       * fees.422       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.423       **/424      limitedReserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV2WeightLimit]>;425      /**426       * Teleport some assets from the local chain to some destination chain.427       * 428       * Fee payment on the destination side is made from the asset in the `assets` vector of429       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight430       * is needed than `weight_limit`, then the operation will fail and the assets send may be431       * at risk.432       * 433       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.434       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send435       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.436       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be437       * an `AccountId32` value.438       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the439       * `dest` side. May not be empty.440       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay441       * fees.442       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.443       **/444      limitedTeleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV2WeightLimit]>;445      /**446       * Transfer some assets from the local chain to the sovereign account of a destination447       * chain and forward a notification XCM.448       * 449       * Fee payment on the destination side is made from the asset in the `assets` vector of450       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,451       * with all fees taken as needed from the asset.452       * 453       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.454       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send455       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.456       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be457       * an `AccountId32` value.458       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the459       * `dest` side.460       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay461       * fees.462       **/463      reserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;464      send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;465      /**466       * Teleport some assets from the local chain to some destination chain.467       * 468       * Fee payment on the destination side is made from the asset in the `assets` vector of469       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,470       * with all fees taken as needed from the asset.471       * 472       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.473       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send474       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.475       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be476       * an `AccountId32` value.477       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the478       * `dest` side. May not be empty.479       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay480       * fees.481       **/482      teleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;483      /**484       * Generic tx485       **/486      [key: string]: SubmittableExtrinsicFunction<ApiType>;487    };488    rmrkCore: {489      /**490       * Accept an NFT sent from another account to self or an owned NFT.491       * 492       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.493       * 494       * # Permissions:495       * - Token-owner-to-be496       * 497       * # Arguments:498       * - `origin`: sender of the transaction499       * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.500       * - `rmrk_nft_id`: ID of the NFT to be accepted.501       * - `new_owner`: Either the sender's account ID or a sender-owned NFT,502       * whichever the accepted NFT was sent to.503       **/504      acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;505      /**506       * Accept the addition of a newly created pending resource to an existing NFT.507       * 508       * This transaction is needed when a resource is created and assigned to an NFT509       * by a non-owner, i.e. the collection issuer, with one of the510       * [`add_...` transactions](Pallet::add_basic_resource).511       * 512       * # Permissions:513       * - Token owner514       * 515       * # Arguments:516       * - `origin`: sender of the transaction517       * - `rmrk_collection_id`: RMRK collection ID of the NFT.518       * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.519       * - `resource_id`: ID of the newly created pending resource.520       * accept the addition of a new resource to an existing NFT521       **/522      acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;523      /**524       * Accept the removal of a removal-pending resource from an NFT.525       * 526       * This transaction is needed when a non-owner, i.e. the collection issuer,527       * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.528       * 529       * # Permissions:530       * - Token owner531       * 532       * # Arguments:533       * - `origin`: sender of the transaction534       * - `rmrk_collection_id`: RMRK collection ID of the NFT.535       * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.536       * - `resource_id`: ID of the removal-pending resource.537       **/538      acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;539      /**540       * Create and set/propose a basic resource for an NFT.541       * 542       * A basic resource is the simplest, lacking a Base and anything that comes with it.543       * See RMRK docs for more information and examples.544       * 545       * # Permissions:546       * - Collection issuer - if not the token owner, adding the resource will warrant547       * the owner's [acceptance](Pallet::accept_resource).548       * 549       * # Arguments:550       * - `origin`: sender of the transaction551       * - `rmrk_collection_id`: RMRK collection ID of the NFT.552       * - `nft_id`: ID of the NFT to assign a resource to.553       * - `resource`: Data of the resource to be created.554       **/555      addBasicResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: RmrkTraitsResourceBasicResource | { src?: any; metadata?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsResourceBasicResource]>;556      /**557       * Create and set/propose a composable resource for an NFT.558       * 559       * A composable resource links to a Base and has a subset of its Parts it is composed of.560       * See RMRK docs for more information and examples.561       * 562       * # Permissions:563       * - Collection issuer - if not the token owner, adding the resource will warrant564       * the owner's [acceptance](Pallet::accept_resource).565       * 566       * # Arguments:567       * - `origin`: sender of the transaction568       * - `rmrk_collection_id`: RMRK collection ID of the NFT.569       * - `nft_id`: ID of the NFT to assign a resource to.570       * - `resource`: Data of the resource to be created.571       **/572      addComposableResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: RmrkTraitsResourceComposableResource | { parts?: any; base?: any; src?: any; metadata?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsResourceComposableResource]>;573      /**574       * Create and set/propose a slot resource for an NFT.575       * 576       * A slot resource links to a Base and a slot ID in it which it can fit into.577       * See RMRK docs for more information and examples.578       * 579       * # Permissions:580       * - Collection issuer - if not the token owner, adding the resource will warrant581       * the owner's [acceptance](Pallet::accept_resource).582       * 583       * # Arguments:584       * - `origin`: sender of the transaction585       * - `rmrk_collection_id`: RMRK collection ID of the NFT.586       * - `nft_id`: ID of the NFT to assign a resource to.587       * - `resource`: Data of the resource to be created.588       **/589      addSlotResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: RmrkTraitsResourceSlotResource | { base?: any; src?: any; metadata?: any; slot?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsResourceSlotResource]>;590      /**591       * Burn an NFT, destroying it and its nested tokens up to the specified limit.592       * If the burning budget is exceeded, the transaction is reverted.593       * 594       * This is the way to burn a nested token as well.595       * 596       * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).597       * 598       * # Permissions:599       * * Token owner600       * 601       * # Arguments:602       * - `origin`: sender of the transaction603       * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.604       * - `nft_id`: ID of the NFT to be destroyed.605       * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction606       * is reverted if there are more tokens to burn in the nesting tree than this number.607       * This is primarily a mechanism of transaction weight control.608       **/609      burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;610      /**611       * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).612       * 613       * # Permissions:614       * * Collection issuer615       * 616       * # Arguments:617       * - `origin`: sender of the transaction618       * - `collection_id`: RMRK collection ID to change the issuer of.619       * - `new_issuer`: Collection's new issuer.620       **/621      changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;622      /**623       * Create a new collection of NFTs.624       * 625       * # Permissions:626       * * Anyone - will be assigned as the issuer of the collection.627       * 628       * # Arguments:629       * - `origin`: sender of the transaction630       * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.631       * - `max`: Optional maximum number of tokens.632       * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.633       * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.634       **/635      createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;636      /**637       * Destroy a collection.638       * 639       * Only empty collections can be destroyed. If it has any tokens, they must be burned first.640       * 641       * # Permissions:642       * * Collection issuer643       * 644       * # Arguments:645       * - `origin`: sender of the transaction646       * - `collection_id`: RMRK ID of the collection to destroy.647       **/648      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;649      /**650       * "Lock" the collection and prevent new token creation. Cannot be undone.651       * 652       * # Permissions:653       * * Collection issuer654       * 655       * # Arguments:656       * - `origin`: sender of the transaction657       * - `collection_id`: RMRK ID of the collection to lock.658       **/659      lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;660      /**661       * Mint an NFT in a specified collection.662       * 663       * # Permissions:664       * * Collection issuer665       * 666       * # Arguments:667       * - `origin`: sender of the transaction668       * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).669       * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.670       * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.671       * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.672       * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.673       * - `transferable`: Can this NFT be transferred? Cannot be changed.674       * - `resources`: Resource data to be added to the NFT immediately after minting.675       **/676      mintNft: AugmentedSubmittable<(owner: Option<AccountId32> | null | Uint8Array | AccountId32 | string, collectionId: u32 | AnyNumber | Uint8Array, recipient: Option<AccountId32> | null | Uint8Array | AccountId32 | string, royaltyAmount: Option<Permill> | null | Uint8Array | Permill | AnyNumber, metadata: Bytes | string | Uint8Array, transferable: bool | boolean | Uint8Array, resources: Option<Vec<RmrkTraitsResourceResourceTypes>> | null | Uint8Array | Vec<RmrkTraitsResourceResourceTypes> | (RmrkTraitsResourceResourceTypes | { Basic: any } | { Composable: any } | { Slot: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<AccountId32>, u32, Option<AccountId32>, Option<Permill>, Bytes, bool, Option<Vec<RmrkTraitsResourceResourceTypes>>]>;677      /**678       * Reject an NFT sent from another account to self or owned NFT.679       * The NFT in question will not be sent back and burnt instead.680       * 681       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.682       * 683       * # Permissions:684       * - Token-owner-to-be-not685       * 686       * # Arguments:687       * - `origin`: sender of the transaction688       * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.689       * - `rmrk_nft_id`: ID of the NFT to be rejected.690       **/691      rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;692      /**693       * Remove and erase a resource from an NFT.694       * 695       * If the sender does not own the NFT, then it will be pending confirmation,696       * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.697       * 698       * # Permissions699       * - Collection issuer700       * 701       * # Arguments702       * - `origin`: sender of the transaction703       * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.704       * - `nft_id`: ID of the NFT with a resource to be removed.705       * - `resource_id`: ID of the resource to be removed.706       **/707      removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;708      /**709       * Transfer an NFT from an account/NFT A to another account/NFT B.710       * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].711       * 712       * If the target owner is an NFT owned by another account, then the NFT will enter713       * the pending state and will have to be accepted by the other account.714       * 715       * # Permissions:716       * - Token owner717       * 718       * # Arguments:719       * - `origin`: sender of the transaction720       * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.721       * - `rmrk_nft_id`: ID of the NFT to be transferred.722       * - `new_owner`: New owner of the nft which can be either an account or a NFT.723       **/724      send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;725      /**726       * Set a different order of resource priorities for an NFT. Priorities can be used,727       * for example, for order of rendering.728       * 729       * Note that the priorities are not updated automatically, and are an empty vector730       * by default. There is no pre-set definition for the order to be particular,731       * it can be interpreted arbitrarily use-case by use-case.732       * 733       * # Permissions:734       * - Token owner735       * 736       * # Arguments:737       * - `origin`: sender of the transaction738       * - `rmrk_collection_id`: RMRK collection ID of the NFT.739       * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.740       * - `priorities`: Ordered vector of resource IDs.741       **/742      setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;743      /**744       * Add or edit a custom user property, a key-value pair, describing the metadata745       * of a token or a collection, on either one of these.746       * 747       * Note that in this proxy implementation many details regarding RMRK are stored748       * as scoped properties prefixed with "rmrk:", normally inaccessible749       * to external transactions and RPCs.750       * 751       * # Permissions:752       * - Collection issuer - in case of collection property753       * - Token owner - in case of NFT property754       * 755       * # Arguments:756       * - `origin`: sender of the transaction757       * - `rmrk_collection_id`: RMRK collection ID.758       * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.759       * - `key`: Key of the custom property to be referenced by.760       * - `value`: Value of the custom property to be stored.761       **/762      setProperty: AugmentedSubmittable<(rmrkCollectionId: Compact<u32> | AnyNumber | Uint8Array, maybeNftId: Option<u32> | null | Uint8Array | u32 | AnyNumber, key: Bytes | string | Uint8Array, value: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Option<u32>, Bytes, Bytes]>;763      /**764       * Generic tx765       **/766      [key: string]: SubmittableExtrinsicFunction<ApiType>;767    };768    rmrkEquip: {769      /**770       * Create a new Base.771       * 772       * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)773       * 774       * # Permissions775       * - Anyone - will be assigned as the issuer of the Base.776       * 777       * # Arguments:778       * - `origin`: Caller, will be assigned as the issuer of the Base779       * - `base_type`: Arbitrary media type, e.g. "svg".780       * - `symbol`: Arbitrary client-chosen symbol.781       * - `parts`: Array of Fixed and Slot Parts composing the Base,782       * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).783       **/784      createBase: AugmentedSubmittable<(baseType: Bytes | string | Uint8Array, symbol: Bytes | string | Uint8Array, parts: Vec<RmrkTraitsPartPartType> | (RmrkTraitsPartPartType | { FixedPart: any } | { SlotPart: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Bytes, Bytes, Vec<RmrkTraitsPartPartType>]>;785      /**786       * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.787       * 788       * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).789       * 790       * # Permissions:791       * - Base issuer792       * 793       * # Arguments:794       * - `origin`: sender of the transaction795       * - `base_id`: Base containing the Slot Part to be updated.796       * - `slot_id`: Slot Part whose Equippable List is being updated .797       * - `equippables`: List of equippables that will override the current Equippables list.798       **/799      equippable: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, slotId: u32 | AnyNumber | Uint8Array, equippables: RmrkTraitsPartEquippableList | { All: any } | { Empty: any } | { Custom: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsPartEquippableList]>;800      /**801       * Add a Theme to a Base.802       * A Theme named "default" is required prior to adding other Themes.803       * 804       * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).805       * 806       * # Permissions:807       * - Base issuer808       * 809       * # Arguments:810       * - `origin`: sender of the transaction811       * - `base_id`: Base ID containing the Theme to be updated.812       * - `theme`: Theme to add to the Base.  A Theme has a name and properties, which are an813       * array of [key, value, inherit].814       * - `key`: Arbitrary BoundedString, defined by client.815       * - `value`: Arbitrary BoundedString, defined by client.816       * - `inherit`: Optional bool.817       **/818      themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;819      /**820       * Generic tx821       **/822      [key: string]: SubmittableExtrinsicFunction<ApiType>;823    };824    structure: {825      /**826       * Generic tx827       **/828      [key: string]: SubmittableExtrinsicFunction<ApiType>;829    };830    sudo: {831      /**832       * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo833       * key.834       * 835       * The dispatch origin for this call must be _Signed_.836       * 837       * # <weight>838       * - O(1).839       * - Limited storage reads.840       * - One DB change.841       * # </weight>842       **/843      setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;844      /**845       * Authenticates the sudo key and dispatches a function call with `Root` origin.846       * 847       * The dispatch origin for this call must be _Signed_.848       * 849       * # <weight>850       * - O(1).851       * - Limited storage reads.852       * - One DB write (event).853       * - Weight of derivative `call` execution + 10,000.854       * # </weight>855       **/856      sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;857      /**858       * Authenticates the sudo key and dispatches a function call with `Signed` origin from859       * a given account.860       * 861       * The dispatch origin for this call must be _Signed_.862       * 863       * # <weight>864       * - O(1).865       * - Limited storage reads.866       * - One DB write (event).867       * - Weight of derivative `call` execution + 10,000.868       * # </weight>869       **/870      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]>;871      /**872       * Authenticates the sudo key and dispatches a function call with `Root` origin.873       * This function does not check the weight of the call, and instead allows the874       * Sudo user to specify the weight of the call.875       * 876       * The dispatch origin for this call must be _Signed_.877       * 878       * # <weight>879       * - O(1).880       * - The weight of this call is defined by the caller.881       * # </weight>882       **/883      sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, Weight]>;884      /**885       * Generic tx886       **/887      [key: string]: SubmittableExtrinsicFunction<ApiType>;888    };889    system: {890      /**891       * A dispatch that will fill the block weight up to the given ratio.892       **/893      fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;894      /**895       * Kill all storage items with a key that starts with the given prefix.896       * 897       * **NOTE:** We rely on the Root origin to provide us the number of subkeys under898       * the prefix we are removing to accurately calculate the weight of this function.899       **/900      killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;901      /**902       * Kill some items from storage.903       **/904      killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;905      /**906       * Make some on-chain remark.907       * 908       * # <weight>909       * - `O(1)`910       * # </weight>911       **/912      remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;913      /**914       * Make some on-chain remark and emit event.915       **/916      remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;917      /**918       * Set the new runtime code.919       * 920       * # <weight>921       * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`922       * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is923       * expensive).924       * - 1 storage write (codec `O(C)`).925       * - 1 digest item.926       * - 1 event.927       * The weight of this function is dependent on the runtime, but generally this is very928       * expensive. We will treat this as a full block.929       * # </weight>930       **/931      setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;932      /**933       * Set the new runtime code without doing any checks of the given `code`.934       * 935       * # <weight>936       * - `O(C)` where `C` length of `code`937       * - 1 storage write (codec `O(C)`).938       * - 1 digest item.939       * - 1 event.940       * The weight of this function is dependent on the runtime. We will treat this as a full941       * block. # </weight>942       **/943      setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;944      /**945       * Set the number of pages in the WebAssembly environment's heap.946       **/947      setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;948      /**949       * Set some items of storage.950       **/951      setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;952      /**953       * Generic tx954       **/955      [key: string]: SubmittableExtrinsicFunction<ApiType>;956    };957    timestamp: {958      /**959       * Set the current time.960       * 961       * This call should be invoked exactly once per block. It will panic at the finalization962       * phase, if this call hasn't been invoked by that time.963       * 964       * The timestamp should be greater than the previous one by the amount specified by965       * `MinimumPeriod`.966       * 967       * The dispatch origin for this call must be `Inherent`.968       * 969       * # <weight>970       * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)971       * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in972       * `on_finalize`)973       * - 1 event handler `on_timestamp_set`. Must be `O(1)`.974       * # </weight>975       **/976      set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;977      /**978       * Generic tx979       **/980      [key: string]: SubmittableExtrinsicFunction<ApiType>;981    };982    tokens: {983      /**984       * Exactly as `transfer`, except the origin must be root and the source985       * account may be specified.986       * 987       * The dispatch origin for this call must be _Root_.988       * 989       * - `source`: The sender of the transfer.990       * - `dest`: The recipient of the transfer.991       * - `currency_id`: currency type.992       * - `amount`: free balance amount to tranfer.993       **/994      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>]>;995      /**996       * Set the balances of a given account.997       * 998       * This will alter `FreeBalance` and `ReservedBalance` in storage. it999       * will also decrease the total issuance of the system1000       * (`TotalIssuance`). If the new free or reserved balance is below the1001       * existential deposit, it will reap the `AccountInfo`.1002       * 1003       * The dispatch origin for this call is `root`.1004       **/1005      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>]>;1006      /**1007       * Transfer some liquid free balance to another account.1008       * 1009       * `transfer` will set the `FreeBalance` of the sender and receiver.1010       * It will decrease the total issuance of the system by the1011       * `TransferFee`. If the sender's account is below the existential1012       * deposit as a result of the transfer, the account will be reaped.1013       * 1014       * The dispatch origin for this call must be `Signed` by the1015       * transactor.1016       * 1017       * - `dest`: The recipient of the transfer.1018       * - `currency_id`: currency type.1019       * - `amount`: free balance amount to tranfer.1020       **/1021      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>]>;1022      /**1023       * Transfer all remaining balance to the given account.1024       * 1025       * NOTE: This function only attempts to transfer _transferable_1026       * balances. This means that any locked, reserved, or existential1027       * deposits (when `keep_alive` is `true`), will not be transferred by1028       * this function. To ensure that this function results in a killed1029       * account, you might need to prepare the account by removing any1030       * reference counters, storage deposits, etc...1031       * 1032       * The dispatch origin for this call must be `Signed` by the1033       * transactor.1034       * 1035       * - `dest`: The recipient of the transfer.1036       * - `currency_id`: currency type.1037       * - `keep_alive`: A boolean to determine if the `transfer_all`1038       * operation should send all of the funds the account has, causing1039       * the sender account to be killed (false), or transfer everything1040       * except at least the existential deposit, which will guarantee to1041       * keep the sender account alive (true).1042       **/1043      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]>;1044      /**1045       * Same as the [`transfer`] call, but with a check that the transfer1046       * will not kill the origin account.1047       * 1048       * 99% of the time you want [`transfer`] instead.1049       * 1050       * The dispatch origin for this call must be `Signed` by the1051       * transactor.1052       * 1053       * - `dest`: The recipient of the transfer.1054       * - `currency_id`: currency type.1055       * - `amount`: free balance amount to tranfer.1056       **/1057      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>]>;1058      /**1059       * Generic tx1060       **/1061      [key: string]: SubmittableExtrinsicFunction<ApiType>;1062    };1063    treasury: {1064      /**1065       * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1066       * and the original deposit will be returned.1067       * 1068       * May only be called from `T::ApproveOrigin`.1069       * 1070       * # <weight>1071       * - Complexity: O(1).1072       * - DbReads: `Proposals`, `Approvals`1073       * - DbWrite: `Approvals`1074       * # </weight>1075       **/1076      approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1077      /**1078       * Put forward a suggestion for spending. A deposit proportional to the value1079       * is reserved and slashed if the proposal is rejected. It is returned once the1080       * proposal is awarded.1081       * 1082       * # <weight>1083       * - Complexity: O(1)1084       * - DbReads: `ProposalCount`, `origin account`1085       * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1086       * # </weight>1087       **/1088      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]>;1089      /**1090       * Reject a proposed spend. The original deposit will be slashed.1091       * 1092       * May only be called from `T::RejectOrigin`.1093       * 1094       * # <weight>1095       * - Complexity: O(1)1096       * - DbReads: `Proposals`, `rejected proposer account`1097       * - DbWrites: `Proposals`, `rejected proposer account`1098       * # </weight>1099       **/1100      rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1101      /**1102       * Force a previously approved proposal to be removed from the approval queue.1103       * The original deposit will no longer be returned.1104       * 1105       * May only be called from `T::RejectOrigin`.1106       * - `proposal_id`: The index of a proposal1107       * 1108       * # <weight>1109       * - Complexity: O(A) where `A` is the number of approvals1110       * - Db reads and writes: `Approvals`1111       * # </weight>1112       * 1113       * Errors:1114       * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1115       * i.e., the proposal has not been approved. This could also mean the proposal does not1116       * exist altogether, thus there is no way it would have been approved in the first place.1117       **/1118      removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1119      /**1120       * Propose and approve a spend of treasury funds.1121       * 1122       * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1123       * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1124       * - `beneficiary`: The destination account for the transfer.1125       * 1126       * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1127       * beneficiary.1128       **/1129      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]>;1130      /**1131       * Generic tx1132       **/1133      [key: string]: SubmittableExtrinsicFunction<ApiType>;1134    };1135    unique: {1136      /**1137       * Add an admin to a collection.1138       * 1139       * NFT Collection can be controlled by multiple admin addresses1140       * (some which can also be servers, for example). Admins can issue1141       * and burn NFTs, as well as add and remove other admins,1142       * but cannot change NFT or Collection ownership.1143       * 1144       * # Permissions1145       * 1146       * * Collection owner1147       * * Collection admin1148       * 1149       * # Arguments1150       * 1151       * * `collection_id`: ID of the Collection to add an admin for.1152       * * `new_admin`: Address of new admin to add.1153       **/1154      addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1155      /**1156       * Add an address to allow list.1157       * 1158       * # Permissions1159       * 1160       * * Collection owner1161       * * Collection admin1162       * 1163       * # Arguments1164       * 1165       * * `collection_id`: ID of the modified collection.1166       * * `address`: ID of the address to be added to the allowlist.1167       **/1168      addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1169      /**1170       * Allow a non-permissioned address to transfer or burn an item.1171       * 1172       * # Permissions1173       * 1174       * * Collection owner1175       * * Collection admin1176       * * Current item owner1177       * 1178       * # Arguments1179       * 1180       * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1181       * * `collection_id`: ID of the collection the item belongs to.1182       * * `item_id`: ID of the item transactions on which are now approved.1183       * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1184       * Set to 0 to revoke the approval.1185       **/1186      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]>;1187      /**1188       * Destroy a token on behalf of the owner as a non-owner account.1189       * 1190       * See also: [`approve`][`Pallet::approve`].1191       * 1192       * After this method executes, one approval is removed from the total so that1193       * the approved address will not be able to transfer this item again from this owner.1194       * 1195       * # Permissions1196       * 1197       * * Collection owner1198       * * Collection admin1199       * * Current token owner1200       * * Address approved by current item owner1201       * 1202       * # Arguments1203       * 1204       * * `from`: The owner of the burning item.1205       * * `collection_id`: ID of the collection to which the item belongs.1206       * * `item_id`: ID of item to burn.1207       * * `value`: Number of pieces to burn.1208       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1209       * * Fungible Mode: The desired number of pieces to burn.1210       * * Re-Fungible Mode: The desired number of pieces to burn.1211       **/1212      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]>;1213      /**1214       * Destroy an item.1215       * 1216       * # Permissions1217       * 1218       * * Collection owner1219       * * Collection admin1220       * * Current item owner1221       * 1222       * # Arguments1223       * 1224       * * `collection_id`: ID of the collection to which the item belongs.1225       * * `item_id`: ID of item to burn.1226       * * `value`: Number of pieces of the item to destroy.1227       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1228       * * Fungible Mode: The desired number of pieces to burn.1229       * * Re-Fungible Mode: The desired number of pieces to burn.1230       **/1231      burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1232      /**1233       * Change the owner of the collection.1234       * 1235       * # Permissions1236       * 1237       * * Collection owner1238       * 1239       * # Arguments1240       * 1241       * * `collection_id`: ID of the modified collection.1242       * * `new_owner`: ID of the account that will become the owner.1243       **/1244      changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1245      /**1246       * Confirm own sponsorship of a collection, becoming the sponsor.1247       * 1248       * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1249       * Sponsor can pay the fees of a transaction instead of the sender,1250       * but only within specified limits.1251       * 1252       * # Permissions1253       * 1254       * * Sponsor-to-be1255       * 1256       * # Arguments1257       * 1258       * * `collection_id`: ID of the collection with the pending sponsor.1259       **/1260      confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1261      /**1262       * Create a collection of tokens.1263       * 1264       * Each Token may have multiple properties encoded as an array of bytes1265       * of certain length. The initial owner of the collection is set1266       * to the address that signed the transaction and can be changed later.1267       * 1268       * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1269       * 1270       * # Permissions1271       * 1272       * * Anyone - becomes the owner of the new collection.1273       * 1274       * # Arguments1275       * 1276       * * `collection_name`: Wide-character string with collection name1277       * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1278       * * `collection_description`: Wide-character string with collection description1279       * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1280       * * `token_prefix`: Byte string containing the token prefix to mark a collection1281       * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1282       * * `mode`: Type of items stored in the collection and type dependent data.1283       **/1284      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]>;1285      /**1286       * Create a collection with explicit parameters.1287       * 1288       * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1289       * 1290       * # Permissions1291       * 1292       * * Anyone - becomes the owner of the new collection.1293       * 1294       * # Arguments1295       * 1296       * * `data`: Explicit data of a collection used for its creation.1297       **/1298      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]>;1299      /**1300       * Mint an item within a collection.1301       * 1302       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1303       * 1304       * # Permissions1305       * 1306       * * Collection owner1307       * * Collection admin1308       * * Anyone if1309       * * Allow List is enabled, and1310       * * Address is added to allow list, and1311       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1312       * 1313       * # Arguments1314       * 1315       * * `collection_id`: ID of the collection to which an item would belong.1316       * * `owner`: Address of the initial owner of the item.1317       * * `data`: Token data describing the item to store on chain.1318       **/1319      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]>;1320      /**1321       * Create multiple items within a collection.1322       * 1323       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1324       * 1325       * # Permissions1326       * 1327       * * Collection owner1328       * * Collection admin1329       * * Anyone if1330       * * Allow List is enabled, and1331       * * Address is added to the allow list, and1332       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1333       * 1334       * # Arguments1335       * 1336       * * `collection_id`: ID of the collection to which the tokens would belong.1337       * * `owner`: Address of the initial owner of the tokens.1338       * * `items_data`: Vector of data describing each item to be created.1339       **/1340      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>]>;1341      /**1342       * Create multiple items within a collection with explicitly specified initial parameters.1343       * 1344       * # Permissions1345       * 1346       * * Collection owner1347       * * Collection admin1348       * * Anyone if1349       * * Allow List is enabled, and1350       * * Address is added to allow list, and1351       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1352       * 1353       * # Arguments1354       * 1355       * * `collection_id`: ID of the collection to which the tokens would belong.1356       * * `data`: Explicit item creation data.1357       **/1358      createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1359      /**1360       * Delete specified collection properties.1361       * 1362       * # Permissions1363       * 1364       * * Collection Owner1365       * * Collection Admin1366       * 1367       * # Arguments1368       * 1369       * * `collection_id`: ID of the modified collection.1370       * * `property_keys`: Vector of keys of the properties to be deleted.1371       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1372       **/1373      deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1374      /**1375       * Delete specified token properties. Currently properties only work with NFTs.1376       * 1377       * # Permissions1378       * 1379       * * Depends on collection's token property permissions and specified property mutability:1380       * * Collection owner1381       * * Collection admin1382       * * Token owner1383       * 1384       * # Arguments1385       * 1386       * * `collection_id`: ID of the collection to which the token belongs.1387       * * `token_id`: ID of the modified token.1388       * * `property_keys`: Vector of keys of the properties to be deleted.1389       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1390       **/1391      deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1392      /**1393       * Destroy a collection if no tokens exist within.1394       * 1395       * # Permissions1396       * 1397       * * Collection owner1398       * 1399       * # Arguments1400       * 1401       * * `collection_id`: Collection to destroy.1402       **/1403      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1404      /**1405       * Remove admin of a collection.1406       * 1407       * An admin address can remove itself. List of admins may become empty,1408       * in which case only Collection Owner will be able to add an Admin.1409       * 1410       * # Permissions1411       * 1412       * * Collection owner1413       * * Collection admin1414       * 1415       * # Arguments1416       * 1417       * * `collection_id`: ID of the collection to remove the admin for.1418       * * `account_id`: Address of the admin to remove.1419       **/1420      removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1421      /**1422       * Remove a collection's a sponsor, making everyone pay for their own transactions.1423       * 1424       * # Permissions1425       * 1426       * * Collection owner1427       * 1428       * # Arguments1429       * 1430       * * `collection_id`: ID of the collection with the sponsor to remove.1431       **/1432      removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1433      /**1434       * Remove an address from allow list.1435       * 1436       * # Permissions1437       * 1438       * * Collection owner1439       * * Collection admin1440       * 1441       * # Arguments1442       * 1443       * * `collection_id`: ID of the modified collection.1444       * * `address`: ID of the address to be removed from the allowlist.1445       **/1446      removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1447      /**1448       * Re-partition a refungible token, while owning all of its parts/pieces.1449       * 1450       * # Permissions1451       * 1452       * * Token owner (must own every part)1453       * 1454       * # Arguments1455       * 1456       * * `collection_id`: ID of the collection the RFT belongs to.1457       * * `token_id`: ID of the RFT.1458       * * `amount`: New number of parts/pieces into which the token shall be partitioned.1459       **/1460      repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1461      /**1462       * Set specific limits of a collection. Empty, or None fields mean chain default.1463       * 1464       * # Permissions1465       * 1466       * * Collection owner1467       * * Collection admin1468       * 1469       * # Arguments1470       * 1471       * * `collection_id`: ID of the modified collection.1472       * * `new_limit`: New limits of the collection. Fields that are not set (None)1473       * will not overwrite the old ones.1474       **/1475      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]>;1476      /**1477       * Set specific permissions of a collection. Empty, or None fields mean chain default.1478       * 1479       * # Permissions1480       * 1481       * * Collection owner1482       * * Collection admin1483       * 1484       * # Arguments1485       * 1486       * * `collection_id`: ID of the modified collection.1487       * * `new_permission`: New permissions of the collection. Fields that are not set (None)1488       * will not overwrite the old ones.1489       **/1490      setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1491      /**1492       * Add or change collection properties.1493       * 1494       * # Permissions1495       * 1496       * * Collection owner1497       * * Collection admin1498       * 1499       * # Arguments1500       * 1501       * * `collection_id`: ID of the modified collection.1502       * * `properties`: Vector of key-value pairs stored as the collection's metadata.1503       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1504       **/1505      setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1506      /**1507       * Set (invite) a new collection sponsor.1508       * 1509       * If successful, confirmation from the sponsor-to-be will be pending.1510       * 1511       * # Permissions1512       * 1513       * * Collection owner1514       * * Collection admin1515       * 1516       * # Arguments1517       * 1518       * * `collection_id`: ID of the modified collection.1519       * * `new_sponsor`: ID of the account of the sponsor-to-be.1520       **/1521      setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1522      /**1523       * Add or change token properties according to collection's permissions.1524       * Currently properties only work with NFTs.1525       * 1526       * # Permissions1527       * 1528       * * Depends on collection's token property permissions and specified property mutability:1529       * * Collection owner1530       * * Collection admin1531       * * Token owner1532       * 1533       * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1534       * 1535       * # Arguments1536       * 1537       * * `collection_id: ID of the collection to which the token belongs.1538       * * `token_id`: ID of the modified token.1539       * * `properties`: Vector of key-value pairs stored as the token's metadata.1540       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1541       **/1542      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>]>;1543      /**1544       * Add or change token property permissions of a collection.1545       * 1546       * Without a permission for a particular key, a property with that key1547       * cannot be created in a token.1548       * 1549       * # Permissions1550       * 1551       * * Collection owner1552       * * Collection admin1553       * 1554       * # Arguments1555       * 1556       * * `collection_id`: ID of the modified collection.1557       * * `property_permissions`: Vector of permissions for property keys.1558       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1559       **/1560      setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1561      /**1562       * Completely allow or disallow transfers for a particular collection.1563       * 1564       * # Permissions1565       * 1566       * * Collection owner1567       * 1568       * # Arguments1569       * 1570       * * `collection_id`: ID of the collection.1571       * * `value`: New value of the flag, are transfers allowed?1572       **/1573      setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1574      /**1575       * Change ownership of the token.1576       * 1577       * # Permissions1578       * 1579       * * Collection owner1580       * * Collection admin1581       * * Current token owner1582       * 1583       * # Arguments1584       * 1585       * * `recipient`: Address of token recipient.1586       * * `collection_id`: ID of the collection the item belongs to.1587       * * `item_id`: ID of the item.1588       * * Non-Fungible Mode: Required.1589       * * Fungible Mode: Ignored.1590       * * Re-Fungible Mode: Required.1591       * 1592       * * `value`: Amount to transfer.1593       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1594       * * Fungible Mode: The desired number of pieces to transfer.1595       * * Re-Fungible Mode: The desired number of pieces to transfer.1596       **/1597      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]>;1598      /**1599       * Change ownership of an item on behalf of the owner as a non-owner account.1600       * 1601       * See the [`approve`][`Pallet::approve`] method for additional information.1602       * 1603       * After this method executes, one approval is removed from the total so that1604       * the approved address will not be able to transfer this item again from this owner.1605       * 1606       * # Permissions1607       * 1608       * * Collection owner1609       * * Collection admin1610       * * Current item owner1611       * * Address approved by current item owner1612       * 1613       * # Arguments1614       * 1615       * * `from`: Address that currently owns the token.1616       * * `recipient`: Address of the new token-owner-to-be.1617       * * `collection_id`: ID of the collection the item.1618       * * `item_id`: ID of the item to be transferred.1619       * * `value`: Amount to transfer.1620       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1621       * * Fungible Mode: The desired number of pieces to transfer.1622       * * Re-Fungible Mode: The desired number of pieces to transfer.1623       **/1624      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]>;1625      /**1626       * Generic tx1627       **/1628      [key: string]: SubmittableExtrinsicFunction<ApiType>;1629    };1630    vesting: {1631      claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1632      claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1633      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>]>;1634      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]>;1635      /**1636       * Generic tx1637       **/1638      [key: string]: SubmittableExtrinsicFunction<ApiType>;1639    };1640    xcmpQueue: {1641      /**1642       * Resumes all XCM executions for the XCMP queue.1643       * 1644       * Note that this function doesn't change the status of the in/out bound channels.1645       * 1646       * - `origin`: Must pass `ControllerOrigin`.1647       **/1648      resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1649      /**1650       * Services a single overweight XCM.1651       * 1652       * - `origin`: Must pass `ExecuteOverweightOrigin`.1653       * - `index`: The index of the overweight XCM to service1654       * - `weight_limit`: The amount of weight that XCM execution may take.1655       * 1656       * Errors:1657       * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1658       * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1659       * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1660       * 1661       * Events:1662       * - `OverweightServiced`: On success.1663       **/1664      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, Weight]>;1665      /**1666       * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1667       * 1668       * - `origin`: Must pass `ControllerOrigin`.1669       **/1670      suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1671      /**1672       * Overwrites the number of pages of messages which must be in the queue after which we drop any further1673       * messages from the channel.1674       * 1675       * - `origin`: Must pass `Root`.1676       * - `new`: Desired value for `QueueConfigData.drop_threshold`1677       **/1678      updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1679      /**1680       * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1681       * message sending may recommence after it has been suspended.1682       * 1683       * - `origin`: Must pass `Root`.1684       * - `new`: Desired value for `QueueConfigData.resume_threshold`1685       **/1686      updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1687      /**1688       * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1689       * suspend their sending.1690       * 1691       * - `origin`: Must pass `Root`.1692       * - `new`: Desired value for `QueueConfigData.suspend_value`1693       **/1694      updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1695      /**1696       * Overwrites the amount of remaining weight under which we stop processing messages.1697       * 1698       * - `origin`: Must pass `Root`.1699       * - `new`: Desired value for `QueueConfigData.threshold_weight`1700       **/1701      updateThresholdWeight: AugmentedSubmittable<(updated: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Weight]>;1702      /**1703       * Overwrites the speed to which the available weight approaches the maximum weight.1704       * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1705       * 1706       * - `origin`: Must pass `Root`.1707       * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1708       **/1709      updateWeightRestrictDecay: AugmentedSubmittable<(updated: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Weight]>;1710      /**1711       * Overwrite the maximum amount of weight any individual message may consume.1712       * Messages above this weight go into the overweight queue and may only be serviced explicitly.1713       * 1714       * - `origin`: Must pass `Root`.1715       * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1716       **/1717      updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Weight]>;1718      /**1719       * Generic tx1720       **/1721      [key: string]: SubmittableExtrinsicFunction<ApiType>;1722    };1723    xTokens: {1724      /**1725       * Transfer native currencies.1726       * 1727       * `dest_weight` is the weight for XCM execution on the dest chain, and1728       * it would be charged from the transferred assets. If set below1729       * requirements, the execution may fail and assets wouldn't be1730       * received.1731       * 1732       * It's a no-op if any error on local XCM execution or message sending.1733       * Note sending assets out per se doesn't guarantee they would be1734       * received. Receiving depends on if the XCM message could be delivered1735       * by the network, and if the receiving chain would handle1736       * messages correctly.1737       **/1738      transfer: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, XcmVersionedMultiLocation, u64]>;1739      /**1740       * Transfer `MultiAsset`.1741       * 1742       * `dest_weight` is the weight for XCM execution on the dest chain, and1743       * it would be charged from the transferred assets. If set below1744       * requirements, the execution may fail and assets wouldn't be1745       * received.1746       * 1747       * It's a no-op if any error on local XCM execution or message sending.1748       * Note sending assets out per se doesn't guarantee they would be1749       * received. Receiving depends on if the XCM message could be delivered1750       * by the network, and if the receiving chain would handle1751       * messages correctly.1752       **/1753      transferMultiasset: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiLocation, u64]>;1754      /**1755       * Transfer several `MultiAsset` specifying the item to be used as fee1756       * 1757       * `dest_weight` is the weight for XCM execution on the dest chain, and1758       * it would be charged from the transferred assets. If set below1759       * requirements, the execution may fail and assets wouldn't be1760       * received.1761       * 1762       * `fee_item` is index of the MultiAssets that we want to use for1763       * payment1764       * 1765       * It's a no-op if any error on local XCM execution or message sending.1766       * Note sending assets out per se doesn't guarantee they would be1767       * received. Receiving depends on if the XCM message could be delivered1768       * by the network, and if the receiving chain would handle1769       * messages correctly.1770       **/1771      transferMultiassets: AugmentedSubmittable<(assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAssets, u32, XcmVersionedMultiLocation, u64]>;1772      /**1773       * Transfer `MultiAsset` specifying the fee and amount as separate.1774       * 1775       * `dest_weight` is the weight for XCM execution on the dest chain, and1776       * it would be charged from the transferred assets. If set below1777       * requirements, the execution may fail and assets wouldn't be1778       * received.1779       * 1780       * `fee` is the multiasset to be spent to pay for execution in1781       * destination chain. Both fee and amount will be subtracted form the1782       * callers balance For now we only accept fee and asset having the same1783       * `MultiLocation` id.1784       * 1785       * If `fee` is not high enough to cover for the execution costs in the1786       * destination chain, then the assets will be trapped in the1787       * destination chain1788       * 1789       * It's a no-op if any error on local XCM execution or message sending.1790       * Note sending assets out per se doesn't guarantee they would be1791       * received. Receiving depends on if the XCM message could be delivered1792       * by the network, and if the receiving chain would handle1793       * messages correctly.1794       **/1795      transferMultiassetWithFee: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, fee: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiAsset, XcmVersionedMultiLocation, u64]>;1796      /**1797       * Transfer several currencies specifying the item to be used as fee1798       * 1799       * `dest_weight` is the weight for XCM execution on the dest chain, and1800       * it would be charged from the transferred assets. If set below1801       * requirements, the execution may fail and assets wouldn't be1802       * received.1803       * 1804       * `fee_item` is index of the currencies tuple that we want to use for1805       * payment1806       * 1807       * It's a no-op if any error on local XCM execution or message sending.1808       * Note sending assets out per se doesn't guarantee they would be1809       * received. Receiving depends on if the XCM message could be delivered1810       * by the network, and if the receiving chain would handle1811       * messages correctly.1812       **/1813      transferMulticurrencies: AugmentedSubmittable<(currencies: Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>> | ([PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, u128 | AnyNumber | Uint8Array])[], feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>>, u32, XcmVersionedMultiLocation, u64]>;1814      /**1815       * Transfer native currencies specifying the fee and amount as1816       * separate.1817       * 1818       * `dest_weight` is the weight for XCM execution on the dest chain, and1819       * it would be charged from the transferred assets. If set below1820       * requirements, the execution may fail and assets wouldn't be1821       * received.1822       * 1823       * `fee` is the amount to be spent to pay for execution in destination1824       * chain. Both fee and amount will be subtracted form the callers1825       * balance.1826       * 1827       * If `fee` is not high enough to cover for the execution costs in the1828       * destination chain, then the assets will be trapped in the1829       * destination chain1830       * 1831       * It's a no-op if any error on local XCM execution or message sending.1832       * Note sending assets out per se doesn't guarantee they would be1833       * received. Receiving depends on if the XCM message could be delivered1834       * by the network, and if the receiving chain would handle1835       * messages correctly.1836       **/1837      transferWithFee: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, fee: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, u128, XcmVersionedMultiLocation, u64]>;1838      /**1839       * Generic tx1840       **/1841      [key: string]: SubmittableExtrinsicFunction<ApiType>;1842    };1843  } // AugmentedSubmittables1844} // declare module