`4bcecc1a2d37`

source

tests/src/interfaces/augment-api-tx.ts97.8 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, U8aFixed, 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 } from '@polkadot/types/interfaces/runtime';12import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, FrameSupportScheduleMaybeHashed, 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    balances: {21      /**22       * Exactly as `transfer`, except the origin must be root and the source account may be23       * specified.24       * # <weight>25       * - Same as transfer, but additional read and write because the source account is not26       * assumed to be in the overlay.27       * # </weight>28       **/29      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>]>;30      /**31       * Unreserve some balance from a user by force.32       * 33       * Can only be called by ROOT.34       **/35      forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;36      /**37       * Set the balances of a given account.38       * 39       * This will alter `FreeBalance` and `ReservedBalance` in storage. it will40       * also alter the total issuance of the system (`TotalIssuance`) appropriately.41       * If the new free or reserved balance is below the existential deposit,42       * it will reset the account nonce (`frame_system::AccountNonce`).43       * 44       * The dispatch origin for this call is `root`.45       **/46      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>]>;47      /**48       * Transfer some liquid free balance to another account.49       * 50       * `transfer` will set the `FreeBalance` of the sender and receiver.51       * If the sender's account is below the existential deposit as a result52       * of the transfer, the account will be reaped.53       * 54       * The dispatch origin for this call must be `Signed` by the transactor.55       * 56       * # <weight>57       * - Dependent on arguments but not critical, given proper implementations for input config58       * types. See related functions below.59       * - It contains a limited number of reads and writes internally and no complex60       * computation.61       * 62       * Related functions:63       * 64       * - `ensure_can_withdraw` is always called internally but has a bounded complexity.65       * - Transferring balances to accounts that did not exist before will cause66       * `T::OnNewAccount::on_new_account` to be called.67       * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.68       * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check69       * that the transfer will not kill the origin account.70       * ---------------------------------71       * - Origin account is already in memory, so no DB operations for them.72       * # </weight>73       **/74      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>]>;75      /**76       * Transfer the entire transferable balance from the caller account.77       * 78       * NOTE: This function only attempts to transfer _transferable_ balances. This means that79       * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be80       * transferred by this function. To ensure that this function results in a killed account,81       * you might need to prepare the account by removing any reference counters, storage82       * deposits, etc...83       * 84       * The dispatch origin of this call must be Signed.85       * 86       * - `dest`: The recipient of the transfer.87       * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all88       * of the funds the account has, causing the sender account to be killed (false), or89       * transfer everything except at least the existential deposit, which will guarantee to90       * keep the sender account alive (true). # <weight>91       * - O(1). Just like transfer, but reading the user's transferable balance first.92       * #</weight>93       **/94      transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;95      /**96       * Same as the [`transfer`] call, but with a check that the transfer will not kill the97       * origin account.98       * 99       * 99% of the time you want [`transfer`] instead.100       * 101       * [`transfer`]: struct.Pallet.html#method.transfer102       **/103      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>]>;104      /**105       * Generic tx106       **/107      [key: string]: SubmittableExtrinsicFunction<ApiType>;108    };109    charging: {110      /**111       * Generic tx112       **/113      [key: string]: SubmittableExtrinsicFunction<ApiType>;114    };115    configuration: {116      setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;117      setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;118      /**119       * Generic tx120       **/121      [key: string]: SubmittableExtrinsicFunction<ApiType>;122    };123    cumulusXcm: {124      /**125       * Generic tx126       **/127      [key: string]: SubmittableExtrinsicFunction<ApiType>;128    };129    dmpQueue: {130      /**131       * Service a single overweight message.132       * 133       * - `origin`: Must pass `ExecuteOverweightOrigin`.134       * - `index`: The index of the overweight message to service.135       * - `weight_limit`: The amount of weight that message execution may take.136       * 137       * Errors:138       * - `Unknown`: Message of `index` is unknown.139       * - `OverLimit`: Message execution may use greater than `weight_limit`.140       * 141       * Events:142       * - `OverweightServiced`: On success.143       **/144      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;145      /**146       * Generic tx147       **/148      [key: string]: SubmittableExtrinsicFunction<ApiType>;149    };150    ethereum: {151      /**152       * Transact an Ethereum transaction.153       **/154      transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;155      /**156       * Generic tx157       **/158      [key: string]: SubmittableExtrinsicFunction<ApiType>;159    };160    evm: {161      /**162       * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.163       **/164      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>]>>]>;165      /**166       * Issue an EVM create operation. This is similar to a contract creation transaction in167       * Ethereum.168       **/169      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>]>>]>;170      /**171       * Issue an EVM create2 operation.172       **/173      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>]>>]>;174      /**175       * Withdraw balance from EVM into currency/balances pallet.176       **/177      withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;178      /**179       * Generic tx180       **/181      [key: string]: SubmittableExtrinsicFunction<ApiType>;182    };183    evmMigration: {184      /**185       * Start contract migration, inserts contract stub at target address,186       * and marks account as pending, allowing to insert storage187       **/188      begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;189      /**190       * Finish contract migration, allows it to be called.191       * It is not possible to alter contract storage via [`Self::set_data`]192       * after this call.193       **/194      finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;195      /**196       * Insert items into contract storage, this method can be called197       * multiple times198       **/199      setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;200      /**201       * Generic tx202       **/203      [key: string]: SubmittableExtrinsicFunction<ApiType>;204    };205    foreignAssets: {206      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]>;207      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]>;208      /**209       * Generic tx210       **/211      [key: string]: SubmittableExtrinsicFunction<ApiType>;212    };213    inflation: {214      /**215       * This method sets the inflation start date. Can be only called once.216       * Inflation start block can be backdated and will catch up. The method will create Treasury217       * account if it does not exist and perform the first inflation deposit.218       * 219       * # Permissions220       * 221       * * Root222       * 223       * # Arguments224       * 225       * * inflation_start_relay_block: The relay chain block at which inflation should start226       **/227      startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;228      /**229       * Generic tx230       **/231      [key: string]: SubmittableExtrinsicFunction<ApiType>;232    };233    parachainSystem: {234      authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;235      enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;236      /**237       * Set the current validation data.238       * 239       * This should be invoked exactly once per block. It will panic at the finalization240       * phase if the call was not invoked.241       * 242       * The dispatch origin for this call must be `Inherent`243       * 244       * As a side effect, this function upgrades the current validation function245       * if the appropriate time has come.246       **/247      setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;248      sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;249      /**250       * Generic tx251       **/252      [key: string]: SubmittableExtrinsicFunction<ApiType>;253    };254    polkadotXcm: {255      /**256       * Execute an XCM message from a local, signed, origin.257       * 258       * An event is deposited indicating whether `msg` could be executed completely or only259       * partially.260       * 261       * No more than `max_weight` will be used in its attempted execution. If this is less than the262       * maximum amount of weight that the message could take to be executed, then no execution263       * attempt will be made.264       * 265       * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully266       * to completion; only that *some* of it was executed.267       **/268      execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;269      /**270       * Set a safe XCM version (the version that XCM should be encoded with if the most recent271       * version a destination can accept is unknown).272       * 273       * - `origin`: Must be Root.274       * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.275       **/276      forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;277      /**278       * Ask a location to notify us regarding their XCM version and any changes to it.279       * 280       * - `origin`: Must be Root.281       * - `location`: The location to which we should subscribe for XCM version notifications.282       **/283      forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;284      /**285       * Require that a particular destination should no longer notify us regarding any XCM286       * version changes.287       * 288       * - `origin`: Must be Root.289       * - `location`: The location to which we are currently subscribed for XCM version290       * notifications which we no longer desire.291       **/292      forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;293      /**294       * Extoll that a particular destination can be communicated with through a particular295       * version of XCM.296       * 297       * - `origin`: Must be Root.298       * - `location`: The destination that is being described.299       * - `xcm_version`: The latest version of XCM that `location` supports.300       **/301      forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;302      /**303       * Transfer some assets from the local chain to the sovereign account of a destination304       * chain and forward a notification XCM.305       * 306       * Fee payment on the destination side is made from the asset in the `assets` vector of307       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight308       * is needed than `weight_limit`, then the operation will fail and the assets send may be309       * at risk.310       * 311       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.312       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send313       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.314       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be315       * an `AccountId32` value.316       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the317       * `dest` side.318       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay319       * fees.320       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.321       **/322      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]>;323      /**324       * Teleport some assets from the local chain to some destination chain.325       * 326       * Fee payment on the destination side is made from the asset in the `assets` vector of327       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight328       * is needed than `weight_limit`, then the operation will fail and the assets send may be329       * at risk.330       * 331       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.332       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send333       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.334       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be335       * an `AccountId32` value.336       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the337       * `dest` side. May not be empty.338       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay339       * fees.340       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.341       **/342      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]>;343      /**344       * Transfer some assets from the local chain to the sovereign account of a destination345       * chain and forward a notification XCM.346       * 347       * Fee payment on the destination side is made from the asset in the `assets` vector of348       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,349       * with all fees taken as needed from the asset.350       * 351       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.352       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send353       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.354       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be355       * an `AccountId32` value.356       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the357       * `dest` side.358       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay359       * fees.360       **/361      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]>;362      send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;363      /**364       * Teleport some assets from the local chain to some destination chain.365       * 366       * Fee payment on the destination side is made from the asset in the `assets` vector of367       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,368       * with all fees taken as needed from the asset.369       * 370       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.371       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send372       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.373       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be374       * an `AccountId32` value.375       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the376       * `dest` side. May not be empty.377       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay378       * fees.379       **/380      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]>;381      /**382       * Generic tx383       **/384      [key: string]: SubmittableExtrinsicFunction<ApiType>;385    };386    rmrkCore: {387      /**388       * Accept an NFT sent from another account to self or an owned NFT.389       * 390       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.391       * 392       * # Permissions:393       * - Token-owner-to-be394       * 395       * # Arguments:396       * - `origin`: sender of the transaction397       * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.398       * - `rmrk_nft_id`: ID of the NFT to be accepted.399       * - `new_owner`: Either the sender's account ID or a sender-owned NFT,400       * whichever the accepted NFT was sent to.401       **/402      acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;403      /**404       * Accept the addition of a newly created pending resource to an existing NFT.405       * 406       * This transaction is needed when a resource is created and assigned to an NFT407       * by a non-owner, i.e. the collection issuer, with one of the408       * [`add_...` transactions](Pallet::add_basic_resource).409       * 410       * # Permissions:411       * - Token owner412       * 413       * # Arguments:414       * - `origin`: sender of the transaction415       * - `rmrk_collection_id`: RMRK collection ID of the NFT.416       * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.417       * - `resource_id`: ID of the newly created pending resource.418       * accept the addition of a new resource to an existing NFT419       **/420      acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;421      /**422       * Accept the removal of a removal-pending resource from an NFT.423       * 424       * This transaction is needed when a non-owner, i.e. the collection issuer,425       * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.426       * 427       * # Permissions:428       * - Token owner429       * 430       * # Arguments:431       * - `origin`: sender of the transaction432       * - `rmrk_collection_id`: RMRK collection ID of the NFT.433       * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.434       * - `resource_id`: ID of the removal-pending resource.435       **/436      acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;437      /**438       * Create and set/propose a basic resource for an NFT.439       * 440       * A basic resource is the simplest, lacking a Base and anything that comes with it.441       * See RMRK docs for more information and examples.442       * 443       * # Permissions:444       * - Collection issuer - if not the token owner, adding the resource will warrant445       * the owner's [acceptance](Pallet::accept_resource).446       * 447       * # Arguments:448       * - `origin`: sender of the transaction449       * - `rmrk_collection_id`: RMRK collection ID of the NFT.450       * - `nft_id`: ID of the NFT to assign a resource to.451       * - `resource`: Data of the resource to be created.452       **/453      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]>;454      /**455       * Create and set/propose a composable resource for an NFT.456       * 457       * A composable resource links to a Base and has a subset of its Parts it is composed of.458       * See RMRK docs for more information and examples.459       * 460       * # Permissions:461       * - Collection issuer - if not the token owner, adding the resource will warrant462       * the owner's [acceptance](Pallet::accept_resource).463       * 464       * # Arguments:465       * - `origin`: sender of the transaction466       * - `rmrk_collection_id`: RMRK collection ID of the NFT.467       * - `nft_id`: ID of the NFT to assign a resource to.468       * - `resource`: Data of the resource to be created.469       **/470      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]>;471      /**472       * Create and set/propose a slot resource for an NFT.473       * 474       * A slot resource links to a Base and a slot ID in it which it can fit into.475       * See RMRK docs for more information and examples.476       * 477       * # Permissions:478       * - Collection issuer - if not the token owner, adding the resource will warrant479       * the owner's [acceptance](Pallet::accept_resource).480       * 481       * # Arguments:482       * - `origin`: sender of the transaction483       * - `rmrk_collection_id`: RMRK collection ID of the NFT.484       * - `nft_id`: ID of the NFT to assign a resource to.485       * - `resource`: Data of the resource to be created.486       **/487      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]>;488      /**489       * Burn an NFT, destroying it and its nested tokens up to the specified limit.490       * If the burning budget is exceeded, the transaction is reverted.491       * 492       * This is the way to burn a nested token as well.493       * 494       * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).495       * 496       * # Permissions:497       * * Token owner498       * 499       * # Arguments:500       * - `origin`: sender of the transaction501       * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.502       * - `nft_id`: ID of the NFT to be destroyed.503       * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction504       * is reverted if there are more tokens to burn in the nesting tree than this number.505       * This is primarily a mechanism of transaction weight control.506       **/507      burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;508      /**509       * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).510       * 511       * # Permissions:512       * * Collection issuer513       * 514       * # Arguments:515       * - `origin`: sender of the transaction516       * - `collection_id`: RMRK collection ID to change the issuer of.517       * - `new_issuer`: Collection's new issuer.518       **/519      changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;520      /**521       * Create a new collection of NFTs.522       * 523       * # Permissions:524       * * Anyone - will be assigned as the issuer of the collection.525       * 526       * # Arguments:527       * - `origin`: sender of the transaction528       * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.529       * - `max`: Optional maximum number of tokens.530       * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.531       * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.532       **/533      createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;534      /**535       * Destroy a collection.536       * 537       * Only empty collections can be destroyed. If it has any tokens, they must be burned first.538       * 539       * # Permissions:540       * * Collection issuer541       * 542       * # Arguments:543       * - `origin`: sender of the transaction544       * - `collection_id`: RMRK ID of the collection to destroy.545       **/546      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;547      /**548       * "Lock" the collection and prevent new token creation. Cannot be undone.549       * 550       * # Permissions:551       * * Collection issuer552       * 553       * # Arguments:554       * - `origin`: sender of the transaction555       * - `collection_id`: RMRK ID of the collection to lock.556       **/557      lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;558      /**559       * Mint an NFT in a specified collection.560       * 561       * # Permissions:562       * * Collection issuer563       * 564       * # Arguments:565       * - `origin`: sender of the transaction566       * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).567       * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.568       * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.569       * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.570       * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.571       * - `transferable`: Can this NFT be transferred? Cannot be changed.572       * - `resources`: Resource data to be added to the NFT immediately after minting.573       **/574      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>>]>;575      /**576       * Reject an NFT sent from another account to self or owned NFT.577       * The NFT in question will not be sent back and burnt instead.578       * 579       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.580       * 581       * # Permissions:582       * - Token-owner-to-be-not583       * 584       * # Arguments:585       * - `origin`: sender of the transaction586       * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.587       * - `rmrk_nft_id`: ID of the NFT to be rejected.588       **/589      rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;590      /**591       * Remove and erase a resource from an NFT.592       * 593       * If the sender does not own the NFT, then it will be pending confirmation,594       * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.595       * 596       * # Permissions597       * - Collection issuer598       * 599       * # Arguments600       * - `origin`: sender of the transaction601       * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.602       * - `nft_id`: ID of the NFT with a resource to be removed.603       * - `resource_id`: ID of the resource to be removed.604       **/605      removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;606      /**607       * Transfer an NFT from an account/NFT A to another account/NFT B.608       * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].609       * 610       * If the target owner is an NFT owned by another account, then the NFT will enter611       * the pending state and will have to be accepted by the other account.612       * 613       * # Permissions:614       * - Token owner615       * 616       * # Arguments:617       * - `origin`: sender of the transaction618       * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.619       * - `rmrk_nft_id`: ID of the NFT to be transferred.620       * - `new_owner`: New owner of the nft which can be either an account or a NFT.621       **/622      send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;623      /**624       * Set a different order of resource priorities for an NFT. Priorities can be used,625       * for example, for order of rendering.626       * 627       * Note that the priorities are not updated automatically, and are an empty vector628       * by default. There is no pre-set definition for the order to be particular,629       * it can be interpreted arbitrarily use-case by use-case.630       * 631       * # Permissions:632       * - Token owner633       * 634       * # Arguments:635       * - `origin`: sender of the transaction636       * - `rmrk_collection_id`: RMRK collection ID of the NFT.637       * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.638       * - `priorities`: Ordered vector of resource IDs.639       **/640      setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;641      /**642       * Add or edit a custom user property, a key-value pair, describing the metadata643       * of a token or a collection, on either one of these.644       * 645       * Note that in this proxy implementation many details regarding RMRK are stored646       * as scoped properties prefixed with "rmrk:", normally inaccessible647       * to external transactions and RPCs.648       * 649       * # Permissions:650       * - Collection issuer - in case of collection property651       * - Token owner - in case of NFT property652       * 653       * # Arguments:654       * - `origin`: sender of the transaction655       * - `rmrk_collection_id`: RMRK collection ID.656       * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.657       * - `key`: Key of the custom property to be referenced by.658       * - `value`: Value of the custom property to be stored.659       **/660      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]>;661      /**662       * Generic tx663       **/664      [key: string]: SubmittableExtrinsicFunction<ApiType>;665    };666    rmrkEquip: {667      /**668       * Create a new Base.669       * 670       * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)671       * 672       * # Permissions673       * - Anyone - will be assigned as the issuer of the Base.674       * 675       * # Arguments:676       * - `origin`: Caller, will be assigned as the issuer of the Base677       * - `base_type`: Arbitrary media type, e.g. "svg".678       * - `symbol`: Arbitrary client-chosen symbol.679       * - `parts`: Array of Fixed and Slot Parts composing the Base,680       * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).681       **/682      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>]>;683      /**684       * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.685       * 686       * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).687       * 688       * # Permissions:689       * - Base issuer690       * 691       * # Arguments:692       * - `origin`: sender of the transaction693       * - `base_id`: Base containing the Slot Part to be updated.694       * - `slot_id`: Slot Part whose Equippable List is being updated .695       * - `equippables`: List of equippables that will override the current Equippables list.696       **/697      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]>;698      /**699       * Add a Theme to a Base.700       * A Theme named "default" is required prior to adding other Themes.701       * 702       * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).703       * 704       * # Permissions:705       * - Base issuer706       * 707       * # Arguments:708       * - `origin`: sender of the transaction709       * - `base_id`: Base ID containing the Theme to be updated.710       * - `theme`: Theme to add to the Base.  A Theme has a name and properties, which are an711       * array of [key, value, inherit].712       * - `key`: Arbitrary BoundedString, defined by client.713       * - `value`: Arbitrary BoundedString, defined by client.714       * - `inherit`: Optional bool.715       **/716      themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;717      /**718       * Generic tx719       **/720      [key: string]: SubmittableExtrinsicFunction<ApiType>;721    };722    scheduler: {723      /**724       * Cancel a named scheduled task.725       **/726      cancelNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed]>;727      /**728       * Schedule a named task.729       **/730      scheduleNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, FrameSupportScheduleMaybeHashed]>;731      /**732       * Schedule a named task after a delay.733       * 734       * # <weight>735       * Same as [`schedule_named`](Self::schedule_named).736       * # </weight>737       **/738      scheduleNamedAfter: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, FrameSupportScheduleMaybeHashed]>;739      /**740       * Generic tx741       **/742      [key: string]: SubmittableExtrinsicFunction<ApiType>;743    };744    structure: {745      /**746       * Generic tx747       **/748      [key: string]: SubmittableExtrinsicFunction<ApiType>;749    };750    sudo: {751      /**752       * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo753       * key.754       * 755       * The dispatch origin for this call must be _Signed_.756       * 757       * # <weight>758       * - O(1).759       * - Limited storage reads.760       * - One DB change.761       * # </weight>762       **/763      setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;764      /**765       * Authenticates the sudo key and dispatches a function call with `Root` origin.766       * 767       * The dispatch origin for this call must be _Signed_.768       * 769       * # <weight>770       * - O(1).771       * - Limited storage reads.772       * - One DB write (event).773       * - Weight of derivative `call` execution + 10,000.774       * # </weight>775       **/776      sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;777      /**778       * Authenticates the sudo key and dispatches a function call with `Signed` origin from779       * a given account.780       * 781       * The dispatch origin for this call must be _Signed_.782       * 783       * # <weight>784       * - O(1).785       * - Limited storage reads.786       * - One DB write (event).787       * - Weight of derivative `call` execution + 10,000.788       * # </weight>789       **/790      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]>;791      /**792       * Authenticates the sudo key and dispatches a function call with `Root` origin.793       * This function does not check the weight of the call, and instead allows the794       * Sudo user to specify the weight of the call.795       * 796       * The dispatch origin for this call must be _Signed_.797       * 798       * # <weight>799       * - O(1).800       * - The weight of this call is defined by the caller.801       * # </weight>802       **/803      sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, u64]>;804      /**805       * Generic tx806       **/807      [key: string]: SubmittableExtrinsicFunction<ApiType>;808    };809    system: {810      /**811       * A dispatch that will fill the block weight up to the given ratio.812       **/813      fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;814      /**815       * Kill all storage items with a key that starts with the given prefix.816       * 817       * **NOTE:** We rely on the Root origin to provide us the number of subkeys under818       * the prefix we are removing to accurately calculate the weight of this function.819       **/820      killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;821      /**822       * Kill some items from storage.823       **/824      killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;825      /**826       * Make some on-chain remark.827       * 828       * # <weight>829       * - `O(1)`830       * # </weight>831       **/832      remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;833      /**834       * Make some on-chain remark and emit event.835       **/836      remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;837      /**838       * Set the new runtime code.839       * 840       * # <weight>841       * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`842       * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is843       * expensive).844       * - 1 storage write (codec `O(C)`).845       * - 1 digest item.846       * - 1 event.847       * The weight of this function is dependent on the runtime, but generally this is very848       * expensive. We will treat this as a full block.849       * # </weight>850       **/851      setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;852      /**853       * Set the new runtime code without doing any checks of the given `code`.854       * 855       * # <weight>856       * - `O(C)` where `C` length of `code`857       * - 1 storage write (codec `O(C)`).858       * - 1 digest item.859       * - 1 event.860       * The weight of this function is dependent on the runtime. We will treat this as a full861       * block. # </weight>862       **/863      setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;864      /**865       * Set the number of pages in the WebAssembly environment's heap.866       **/867      setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;868      /**869       * Set some items of storage.870       **/871      setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;872      /**873       * Generic tx874       **/875      [key: string]: SubmittableExtrinsicFunction<ApiType>;876    };877    timestamp: {878      /**879       * Set the current time.880       * 881       * This call should be invoked exactly once per block. It will panic at the finalization882       * phase, if this call hasn't been invoked by that time.883       * 884       * The timestamp should be greater than the previous one by the amount specified by885       * `MinimumPeriod`.886       * 887       * The dispatch origin for this call must be `Inherent`.888       * 889       * # <weight>890       * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)891       * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in892       * `on_finalize`)893       * - 1 event handler `on_timestamp_set`. Must be `O(1)`.894       * # </weight>895       **/896      set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;897      /**898       * Generic tx899       **/900      [key: string]: SubmittableExtrinsicFunction<ApiType>;901    };902    tokens: {903      /**904       * Exactly as `transfer`, except the origin must be root and the source905       * account may be specified.906       * 907       * The dispatch origin for this call must be _Root_.908       * 909       * - `source`: The sender of the transfer.910       * - `dest`: The recipient of the transfer.911       * - `currency_id`: currency type.912       * - `amount`: free balance amount to tranfer.913       **/914      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>]>;915      /**916       * Set the balances of a given account.917       * 918       * This will alter `FreeBalance` and `ReservedBalance` in storage. it919       * will also decrease the total issuance of the system920       * (`TotalIssuance`). If the new free or reserved balance is below the921       * existential deposit, it will reap the `AccountInfo`.922       * 923       * The dispatch origin for this call is `root`.924       **/925      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>]>;926      /**927       * Transfer some liquid free balance to another account.928       * 929       * `transfer` will set the `FreeBalance` of the sender and receiver.930       * It will decrease the total issuance of the system by the931       * `TransferFee`. If the sender's account is below the existential932       * deposit as a result of the transfer, the account will be reaped.933       * 934       * The dispatch origin for this call must be `Signed` by the935       * transactor.936       * 937       * - `dest`: The recipient of the transfer.938       * - `currency_id`: currency type.939       * - `amount`: free balance amount to tranfer.940       **/941      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>]>;942      /**943       * Transfer all remaining balance to the given account.944       * 945       * NOTE: This function only attempts to transfer _transferable_946       * balances. This means that any locked, reserved, or existential947       * deposits (when `keep_alive` is `true`), will not be transferred by948       * this function. To ensure that this function results in a killed949       * account, you might need to prepare the account by removing any950       * reference counters, storage deposits, etc...951       * 952       * The dispatch origin for this call must be `Signed` by the953       * transactor.954       * 955       * - `dest`: The recipient of the transfer.956       * - `currency_id`: currency type.957       * - `keep_alive`: A boolean to determine if the `transfer_all`958       * operation should send all of the funds the account has, causing959       * the sender account to be killed (false), or transfer everything960       * except at least the existential deposit, which will guarantee to961       * keep the sender account alive (true).962       **/963      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]>;964      /**965       * Same as the [`transfer`] call, but with a check that the transfer966       * will not kill the origin account.967       * 968       * 99% of the time you want [`transfer`] instead.969       * 970       * The dispatch origin for this call must be `Signed` by the971       * transactor.972       * 973       * - `dest`: The recipient of the transfer.974       * - `currency_id`: currency type.975       * - `amount`: free balance amount to tranfer.976       **/977      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>]>;978      /**979       * Generic tx980       **/981      [key: string]: SubmittableExtrinsicFunction<ApiType>;982    };983    treasury: {984      /**985       * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary986       * and the original deposit will be returned.987       * 988       * May only be called from `T::ApproveOrigin`.989       * 990       * # <weight>991       * - Complexity: O(1).992       * - DbReads: `Proposals`, `Approvals`993       * - DbWrite: `Approvals`994       * # </weight>995       **/996      approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;997      /**998       * Put forward a suggestion for spending. A deposit proportional to the value999       * is reserved and slashed if the proposal is rejected. It is returned once the1000       * proposal is awarded.1001       * 1002       * # <weight>1003       * - Complexity: O(1)1004       * - DbReads: `ProposalCount`, `origin account`1005       * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1006       * # </weight>1007       **/1008      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]>;1009      /**1010       * Reject a proposed spend. The original deposit will be slashed.1011       * 1012       * May only be called from `T::RejectOrigin`.1013       * 1014       * # <weight>1015       * - Complexity: O(1)1016       * - DbReads: `Proposals`, `rejected proposer account`1017       * - DbWrites: `Proposals`, `rejected proposer account`1018       * # </weight>1019       **/1020      rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1021      /**1022       * Force a previously approved proposal to be removed from the approval queue.1023       * The original deposit will no longer be returned.1024       * 1025       * May only be called from `T::RejectOrigin`.1026       * - `proposal_id`: The index of a proposal1027       * 1028       * # <weight>1029       * - Complexity: O(A) where `A` is the number of approvals1030       * - Db reads and writes: `Approvals`1031       * # </weight>1032       * 1033       * Errors:1034       * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1035       * i.e., the proposal has not been approved. This could also mean the proposal does not1036       * exist altogether, thus there is no way it would have been approved in the first place.1037       **/1038      removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1039      /**1040       * Propose and approve a spend of treasury funds.1041       * 1042       * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1043       * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1044       * - `beneficiary`: The destination account for the transfer.1045       * 1046       * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1047       * beneficiary.1048       **/1049      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]>;1050      /**1051       * Generic tx1052       **/1053      [key: string]: SubmittableExtrinsicFunction<ApiType>;1054    };1055    unique: {1056      /**1057       * Add an admin to a collection.1058       * 1059       * NFT Collection can be controlled by multiple admin addresses1060       * (some which can also be servers, for example). Admins can issue1061       * and burn NFTs, as well as add and remove other admins,1062       * but cannot change NFT or Collection ownership.1063       * 1064       * # Permissions1065       * 1066       * * Collection owner1067       * * Collection admin1068       * 1069       * # Arguments1070       * 1071       * * `collection_id`: ID of the Collection to add an admin for.1072       * * `new_admin`: Address of new admin to add.1073       **/1074      addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1075      /**1076       * Add an address to allow list.1077       * 1078       * # Permissions1079       * 1080       * * Collection owner1081       * * Collection admin1082       * 1083       * # Arguments1084       * 1085       * * `collection_id`: ID of the modified collection.1086       * * `address`: ID of the address to be added to the allowlist.1087       **/1088      addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1089      /**1090       * Allow a non-permissioned address to transfer or burn an item.1091       * 1092       * # Permissions1093       * 1094       * * Collection owner1095       * * Collection admin1096       * * Current item owner1097       * 1098       * # Arguments1099       * 1100       * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1101       * * `collection_id`: ID of the collection the item belongs to.1102       * * `item_id`: ID of the item transactions on which are now approved.1103       * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1104       * Set to 0 to revoke the approval.1105       **/1106      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]>;1107      /**1108       * Destroy a token on behalf of the owner as a non-owner account.1109       * 1110       * See also: [`approve`][`Pallet::approve`].1111       * 1112       * After this method executes, one approval is removed from the total so that1113       * the approved address will not be able to transfer this item again from this owner.1114       * 1115       * # Permissions1116       * 1117       * * Collection owner1118       * * Collection admin1119       * * Current token owner1120       * * Address approved by current item owner1121       * 1122       * # Arguments1123       * 1124       * * `from`: The owner of the burning item.1125       * * `collection_id`: ID of the collection to which the item belongs.1126       * * `item_id`: ID of item to burn.1127       * * `value`: Number of pieces to burn.1128       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1129       * * Fungible Mode: The desired number of pieces to burn.1130       * * Re-Fungible Mode: The desired number of pieces to burn.1131       **/1132      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]>;1133      /**1134       * Destroy an item.1135       * 1136       * # Permissions1137       * 1138       * * Collection owner1139       * * Collection admin1140       * * Current item owner1141       * 1142       * # Arguments1143       * 1144       * * `collection_id`: ID of the collection to which the item belongs.1145       * * `item_id`: ID of item to burn.1146       * * `value`: Number of pieces of the item to destroy.1147       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1148       * * Fungible Mode: The desired number of pieces to burn.1149       * * Re-Fungible Mode: The desired number of pieces to burn.1150       **/1151      burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1152      /**1153       * Change the owner of the collection.1154       * 1155       * # Permissions1156       * 1157       * * Collection owner1158       * 1159       * # Arguments1160       * 1161       * * `collection_id`: ID of the modified collection.1162       * * `new_owner`: ID of the account that will become the owner.1163       **/1164      changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1165      /**1166       * Confirm own sponsorship of a collection, becoming the sponsor.1167       * 1168       * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1169       * Sponsor can pay the fees of a transaction instead of the sender,1170       * but only within specified limits.1171       * 1172       * # Permissions1173       * 1174       * * Sponsor-to-be1175       * 1176       * # Arguments1177       * 1178       * * `collection_id`: ID of the collection with the pending sponsor.1179       **/1180      confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1181      /**1182       * Create a collection of tokens.1183       * 1184       * Each Token may have multiple properties encoded as an array of bytes1185       * of certain length. The initial owner of the collection is set1186       * to the address that signed the transaction and can be changed later.1187       * 1188       * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1189       * 1190       * # Permissions1191       * 1192       * * Anyone - becomes the owner of the new collection.1193       * 1194       * # Arguments1195       * 1196       * * `collection_name`: Wide-character string with collection name1197       * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1198       * * `collection_description`: Wide-character string with collection description1199       * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1200       * * `token_prefix`: Byte string containing the token prefix to mark a collection1201       * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1202       * * `mode`: Type of items stored in the collection and type dependent data.1203       **/1204      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]>;1205      /**1206       * Create a collection with explicit parameters.1207       * 1208       * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1209       * 1210       * # Permissions1211       * 1212       * * Anyone - becomes the owner of the new collection.1213       * 1214       * # Arguments1215       * 1216       * * `data`: Explicit data of a collection used for its creation.1217       **/1218      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]>;1219      /**1220       * Mint an item within a collection.1221       * 1222       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1223       * 1224       * # Permissions1225       * 1226       * * Collection owner1227       * * Collection admin1228       * * Anyone if1229       * * Allow List is enabled, and1230       * * Address is added to allow list, and1231       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1232       * 1233       * # Arguments1234       * 1235       * * `collection_id`: ID of the collection to which an item would belong.1236       * * `owner`: Address of the initial owner of the item.1237       * * `data`: Token data describing the item to store on chain.1238       **/1239      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]>;1240      /**1241       * Create multiple items within a collection.1242       * 1243       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1244       * 1245       * # Permissions1246       * 1247       * * Collection owner1248       * * Collection admin1249       * * Anyone if1250       * * Allow List is enabled, and1251       * * Address is added to the allow list, and1252       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1253       * 1254       * # Arguments1255       * 1256       * * `collection_id`: ID of the collection to which the tokens would belong.1257       * * `owner`: Address of the initial owner of the tokens.1258       * * `items_data`: Vector of data describing each item to be created.1259       **/1260      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>]>;1261      /**1262       * Create multiple items within a collection with explicitly specified initial parameters.1263       * 1264       * # Permissions1265       * 1266       * * Collection owner1267       * * Collection admin1268       * * Anyone if1269       * * Allow List is enabled, and1270       * * Address is added to allow list, and1271       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1272       * 1273       * # Arguments1274       * 1275       * * `collection_id`: ID of the collection to which the tokens would belong.1276       * * `data`: Explicit item creation data.1277       **/1278      createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1279      /**1280       * Delete specified collection properties.1281       * 1282       * # Permissions1283       * 1284       * * Collection Owner1285       * * Collection Admin1286       * 1287       * # Arguments1288       * 1289       * * `collection_id`: ID of the modified collection.1290       * * `property_keys`: Vector of keys of the properties to be deleted.1291       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1292       **/1293      deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1294      /**1295       * Delete specified token properties. Currently properties only work with NFTs.1296       * 1297       * # Permissions1298       * 1299       * * Depends on collection's token property permissions and specified property mutability:1300       * * Collection owner1301       * * Collection admin1302       * * Token owner1303       * 1304       * # Arguments1305       * 1306       * * `collection_id`: ID of the collection to which the token belongs.1307       * * `token_id`: ID of the modified token.1308       * * `property_keys`: Vector of keys of the properties to be deleted.1309       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1310       **/1311      deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1312      /**1313       * Destroy a collection if no tokens exist within.1314       * 1315       * # Permissions1316       * 1317       * * Collection owner1318       * 1319       * # Arguments1320       * 1321       * * `collection_id`: Collection to destroy.1322       **/1323      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1324      /**1325       * Remove admin of a collection.1326       * 1327       * An admin address can remove itself. List of admins may become empty,1328       * in which case only Collection Owner will be able to add an Admin.1329       * 1330       * # Permissions1331       * 1332       * * Collection owner1333       * * Collection admin1334       * 1335       * # Arguments1336       * 1337       * * `collection_id`: ID of the collection to remove the admin for.1338       * * `account_id`: Address of the admin to remove.1339       **/1340      removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1341      /**1342       * Remove a collection's a sponsor, making everyone pay for their own transactions.1343       * 1344       * # Permissions1345       * 1346       * * Collection owner1347       * 1348       * # Arguments1349       * 1350       * * `collection_id`: ID of the collection with the sponsor to remove.1351       **/1352      removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1353      /**1354       * Remove an address from allow list.1355       * 1356       * # Permissions1357       * 1358       * * Collection owner1359       * * Collection admin1360       * 1361       * # Arguments1362       * 1363       * * `collection_id`: ID of the modified collection.1364       * * `address`: ID of the address to be removed from the allowlist.1365       **/1366      removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1367      /**1368       * Re-partition a refungible token, while owning all of its parts/pieces.1369       * 1370       * # Permissions1371       * 1372       * * Token owner (must own every part)1373       * 1374       * # Arguments1375       * 1376       * * `collection_id`: ID of the collection the RFT belongs to.1377       * * `token_id`: ID of the RFT.1378       * * `amount`: New number of parts/pieces into which the token shall be partitioned.1379       **/1380      repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1381      /**1382       * Set specific limits of a collection. Empty, or None fields mean chain default.1383       * 1384       * # Permissions1385       * 1386       * * Collection owner1387       * * Collection admin1388       * 1389       * # Arguments1390       * 1391       * * `collection_id`: ID of the modified collection.1392       * * `new_limit`: New limits of the collection. Fields that are not set (None)1393       * will not overwrite the old ones.1394       **/1395      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]>;1396      /**1397       * Set specific permissions of a collection. Empty, or None fields mean chain default.1398       * 1399       * # Permissions1400       * 1401       * * Collection owner1402       * * Collection admin1403       * 1404       * # Arguments1405       * 1406       * * `collection_id`: ID of the modified collection.1407       * * `new_permission`: New permissions of the collection. Fields that are not set (None)1408       * will not overwrite the old ones.1409       **/1410      setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1411      /**1412       * Add or change collection properties.1413       * 1414       * # Permissions1415       * 1416       * * Collection owner1417       * * Collection admin1418       * 1419       * # Arguments1420       * 1421       * * `collection_id`: ID of the modified collection.1422       * * `properties`: Vector of key-value pairs stored as the collection's metadata.1423       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1424       **/1425      setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1426      /**1427       * Set (invite) a new collection sponsor.1428       * 1429       * If successful, confirmation from the sponsor-to-be will be pending.1430       * 1431       * # Permissions1432       * 1433       * * Collection owner1434       * * Collection admin1435       * 1436       * # Arguments1437       * 1438       * * `collection_id`: ID of the modified collection.1439       * * `new_sponsor`: ID of the account of the sponsor-to-be.1440       **/1441      setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1442      /**1443       * Add or change token properties according to collection's permissions.1444       * Currently properties only work with NFTs.1445       * 1446       * # Permissions1447       * 1448       * * Depends on collection's token property permissions and specified property mutability:1449       * * Collection owner1450       * * Collection admin1451       * * Token owner1452       * 1453       * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1454       * 1455       * # Arguments1456       * 1457       * * `collection_id: ID of the collection to which the token belongs.1458       * * `token_id`: ID of the modified token.1459       * * `properties`: Vector of key-value pairs stored as the token's metadata.1460       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1461       **/1462      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>]>;1463      /**1464       * Add or change token property permissions of a collection.1465       * 1466       * Without a permission for a particular key, a property with that key1467       * cannot be created in a token.1468       * 1469       * # Permissions1470       * 1471       * * Collection owner1472       * * Collection admin1473       * 1474       * # Arguments1475       * 1476       * * `collection_id`: ID of the modified collection.1477       * * `property_permissions`: Vector of permissions for property keys.1478       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1479       **/1480      setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1481      /**1482       * Completely allow or disallow transfers for a particular collection.1483       * 1484       * # Permissions1485       * 1486       * * Collection owner1487       * 1488       * # Arguments1489       * 1490       * * `collection_id`: ID of the collection.1491       * * `value`: New value of the flag, are transfers allowed?1492       **/1493      setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1494      /**1495       * Change ownership of the token.1496       * 1497       * # Permissions1498       * 1499       * * Collection owner1500       * * Collection admin1501       * * Current token owner1502       * 1503       * # Arguments1504       * 1505       * * `recipient`: Address of token recipient.1506       * * `collection_id`: ID of the collection the item belongs to.1507       * * `item_id`: ID of the item.1508       * * Non-Fungible Mode: Required.1509       * * Fungible Mode: Ignored.1510       * * Re-Fungible Mode: Required.1511       * 1512       * * `value`: Amount to transfer.1513       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1514       * * Fungible Mode: The desired number of pieces to transfer.1515       * * Re-Fungible Mode: The desired number of pieces to transfer.1516       **/1517      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]>;1518      /**1519       * Change ownership of an item on behalf of the owner as a non-owner account.1520       * 1521       * See the [`approve`][`Pallet::approve`] method for additional information.1522       * 1523       * After this method executes, one approval is removed from the total so that1524       * the approved address will not be able to transfer this item again from this owner.1525       * 1526       * # Permissions1527       * 1528       * * Collection owner1529       * * Collection admin1530       * * Current item owner1531       * * Address approved by current item owner1532       * 1533       * # Arguments1534       * 1535       * * `from`: Address that currently owns the token.1536       * * `recipient`: Address of the new token-owner-to-be.1537       * * `collection_id`: ID of the collection the item.1538       * * `item_id`: ID of the item to be transferred.1539       * * `value`: Amount to transfer.1540       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1541       * * Fungible Mode: The desired number of pieces to transfer.1542       * * Re-Fungible Mode: The desired number of pieces to transfer.1543       **/1544      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]>;1545      /**1546       * Generic tx1547       **/1548      [key: string]: SubmittableExtrinsicFunction<ApiType>;1549    };1550    vesting: {1551      claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1552      claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1553      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>]>;1554      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]>;1555      /**1556       * Generic tx1557       **/1558      [key: string]: SubmittableExtrinsicFunction<ApiType>;1559    };1560    xcmpQueue: {1561      /**1562       * Resumes all XCM executions for the XCMP queue.1563       * 1564       * Note that this function doesn't change the status of the in/out bound channels.1565       * 1566       * - `origin`: Must pass `ControllerOrigin`.1567       **/1568      resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1569      /**1570       * Services a single overweight XCM.1571       * 1572       * - `origin`: Must pass `ExecuteOverweightOrigin`.1573       * - `index`: The index of the overweight XCM to service1574       * - `weight_limit`: The amount of weight that XCM execution may take.1575       * 1576       * Errors:1577       * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1578       * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1579       * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1580       * 1581       * Events:1582       * - `OverweightServiced`: On success.1583       **/1584      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1585      /**1586       * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1587       * 1588       * - `origin`: Must pass `ControllerOrigin`.1589       **/1590      suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1591      /**1592       * Overwrites the number of pages of messages which must be in the queue after which we drop any further1593       * messages from the channel.1594       * 1595       * - `origin`: Must pass `Root`.1596       * - `new`: Desired value for `QueueConfigData.drop_threshold`1597       **/1598      updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1599      /**1600       * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1601       * message sending may recommence after it has been suspended.1602       * 1603       * - `origin`: Must pass `Root`.1604       * - `new`: Desired value for `QueueConfigData.resume_threshold`1605       **/1606      updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1607      /**1608       * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1609       * suspend their sending.1610       * 1611       * - `origin`: Must pass `Root`.1612       * - `new`: Desired value for `QueueConfigData.suspend_value`1613       **/1614      updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1615      /**1616       * Overwrites the amount of remaining weight under which we stop processing messages.1617       * 1618       * - `origin`: Must pass `Root`.1619       * - `new`: Desired value for `QueueConfigData.threshold_weight`1620       **/1621      updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1622      /**1623       * Overwrites the speed to which the available weight approaches the maximum weight.1624       * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1625       * 1626       * - `origin`: Must pass `Root`.1627       * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1628       **/1629      updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1630      /**1631       * Overwrite the maximum amount of weight any individual message may consume.1632       * Messages above this weight go into the overweight queue and may only be serviced explicitly.1633       * 1634       * - `origin`: Must pass `Root`.1635       * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1636       **/1637      updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1638      /**1639       * Generic tx1640       **/1641      [key: string]: SubmittableExtrinsicFunction<ApiType>;1642    };1643    xTokens: {1644      /**1645       * Transfer native currencies.1646       * 1647       * `dest_weight` is the weight for XCM execution on the dest chain, and1648       * it would be charged from the transferred assets. If set below1649       * requirements, the execution may fail and assets wouldn't be1650       * received.1651       * 1652       * It's a no-op if any error on local XCM execution or message sending.1653       * Note sending assets out per se doesn't guarantee they would be1654       * received. Receiving depends on if the XCM message could be delivered1655       * by the network, and if the receiving chain would handle1656       * messages correctly.1657       **/1658      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]>;1659      /**1660       * Transfer `MultiAsset`.1661       * 1662       * `dest_weight` is the weight for XCM execution on the dest chain, and1663       * it would be charged from the transferred assets. If set below1664       * requirements, the execution may fail and assets wouldn't be1665       * received.1666       * 1667       * It's a no-op if any error on local XCM execution or message sending.1668       * Note sending assets out per se doesn't guarantee they would be1669       * received. Receiving depends on if the XCM message could be delivered1670       * by the network, and if the receiving chain would handle1671       * messages correctly.1672       **/1673      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]>;1674      /**1675       * Transfer several `MultiAsset` specifying the item to be used as fee1676       * 1677       * `dest_weight` is the weight for XCM execution on the dest chain, and1678       * it would be charged from the transferred assets. If set below1679       * requirements, the execution may fail and assets wouldn't be1680       * received.1681       * 1682       * `fee_item` is index of the MultiAssets that we want to use for1683       * payment1684       * 1685       * It's a no-op if any error on local XCM execution or message sending.1686       * Note sending assets out per se doesn't guarantee they would be1687       * received. Receiving depends on if the XCM message could be delivered1688       * by the network, and if the receiving chain would handle1689       * messages correctly.1690       **/1691      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]>;1692      /**1693       * Transfer `MultiAsset` specifying the fee and amount as separate.1694       * 1695       * `dest_weight` is the weight for XCM execution on the dest chain, and1696       * it would be charged from the transferred assets. If set below1697       * requirements, the execution may fail and assets wouldn't be1698       * received.1699       * 1700       * `fee` is the multiasset to be spent to pay for execution in1701       * destination chain. Both fee and amount will be subtracted form the1702       * callers balance For now we only accept fee and asset having the same1703       * `MultiLocation` id.1704       * 1705       * If `fee` is not high enough to cover for the execution costs in the1706       * destination chain, then the assets will be trapped in the1707       * destination chain1708       * 1709       * It's a no-op if any error on local XCM execution or message sending.1710       * Note sending assets out per se doesn't guarantee they would be1711       * received. Receiving depends on if the XCM message could be delivered1712       * by the network, and if the receiving chain would handle1713       * messages correctly.1714       **/1715      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]>;1716      /**1717       * Transfer several currencies specifying the item to be used as fee1718       * 1719       * `dest_weight` is the weight for XCM execution on the dest chain, and1720       * it would be charged from the transferred assets. If set below1721       * requirements, the execution may fail and assets wouldn't be1722       * received.1723       * 1724       * `fee_item` is index of the currencies tuple that we want to use for1725       * payment1726       * 1727       * It's a no-op if any error on local XCM execution or message sending.1728       * Note sending assets out per se doesn't guarantee they would be1729       * received. Receiving depends on if the XCM message could be delivered1730       * by the network, and if the receiving chain would handle1731       * messages correctly.1732       **/1733      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]>;1734      /**1735       * Transfer native currencies specifying the fee and amount as1736       * separate.1737       * 1738       * `dest_weight` is the weight for XCM execution on the dest chain, and1739       * it would be charged from the transferred assets. If set below1740       * requirements, the execution may fail and assets wouldn't be1741       * received.1742       * 1743       * `fee` is the amount to be spent to pay for execution in destination1744       * chain. Both fee and amount will be subtracted form the callers1745       * balance.1746       * 1747       * If `fee` is not high enough to cover for the execution costs in the1748       * destination chain, then the assets will be trapped in the1749       * destination chain1750       * 1751       * It's a no-op if any error on local XCM execution or message sending.1752       * Note sending assets out per se doesn't guarantee they would be1753       * received. Receiving depends on if the XCM message could be delivered1754       * by the network, and if the receiving chain would handle1755       * messages correctly.1756       **/1757      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]>;1758      /**1759       * Generic tx1760       **/1761      [key: string]: SubmittableExtrinsicFunction<ApiType>;1762    };1763  } // AugmentedSubmittables1764} // declare module