`b6fea42a7f33`

source

tests/src/interfaces/augment-api-tx.ts96.5 KiBsource history
1// Auto-generated via `yarn polkadot-types-from-chain`, do not edit2/* eslint-disable */34import type { ApiTypes } from '@polkadot/api-base/types';5import type { Bytes, Compact, Option, U256, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';6import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';7import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill } from '@polkadot/types/interfaces/runtime';8import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, FrameSupportScheduleMaybeHashed, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeingAssetsAssetIds, PalletForeingAssetsModuleAssetMetadata, 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';910declare module '@polkadot/api-base/types/submittable' {11  export interface AugmentedSubmittables<ApiType extends ApiTypes> {12    balances: {13      /**14       * Exactly as `transfer`, except the origin must be root and the source account may be15       * specified.16       * # <weight>17       * - Same as transfer, but additional read and write because the source account is not18       * assumed to be in the overlay.19       * # </weight>20       **/21      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>]>;22      /**23       * Unreserve some balance from a user by force.24       * 25       * Can only be called by ROOT.26       **/27      forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;28      /**29       * Set the balances of a given account.30       * 31       * This will alter `FreeBalance` and `ReservedBalance` in storage. it will32       * also alter the total issuance of the system (`TotalIssuance`) appropriately.33       * If the new free or reserved balance is below the existential deposit,34       * it will reset the account nonce (`frame_system::AccountNonce`).35       * 36       * The dispatch origin for this call is `root`.37       **/38      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>]>;39      /**40       * Transfer some liquid free balance to another account.41       * 42       * `transfer` will set the `FreeBalance` of the sender and receiver.43       * If the sender's account is below the existential deposit as a result44       * of the transfer, the account will be reaped.45       * 46       * The dispatch origin for this call must be `Signed` by the transactor.47       * 48       * # <weight>49       * - Dependent on arguments but not critical, given proper implementations for input config50       * types. See related functions below.51       * - It contains a limited number of reads and writes internally and no complex52       * computation.53       * 54       * Related functions:55       * 56       * - `ensure_can_withdraw` is always called internally but has a bounded complexity.57       * - Transferring balances to accounts that did not exist before will cause58       * `T::OnNewAccount::on_new_account` to be called.59       * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.60       * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check61       * that the transfer will not kill the origin account.62       * ---------------------------------63       * - Origin account is already in memory, so no DB operations for them.64       * # </weight>65       **/66      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>]>;67      /**68       * Transfer the entire transferable balance from the caller account.69       * 70       * NOTE: This function only attempts to transfer _transferable_ balances. This means that71       * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be72       * transferred by this function. To ensure that this function results in a killed account,73       * you might need to prepare the account by removing any reference counters, storage74       * deposits, etc...75       * 76       * The dispatch origin of this call must be Signed.77       * 78       * - `dest`: The recipient of the transfer.79       * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all80       * of the funds the account has, causing the sender account to be killed (false), or81       * transfer everything except at least the existential deposit, which will guarantee to82       * keep the sender account alive (true). # <weight>83       * - O(1). Just like transfer, but reading the user's transferable balance first.84       * #</weight>85       **/86      transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;87      /**88       * Same as the [`transfer`] call, but with a check that the transfer will not kill the89       * origin account.90       * 91       * 99% of the time you want [`transfer`] instead.92       * 93       * [`transfer`]: struct.Pallet.html#method.transfer94       **/95      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>]>;96      /**97       * Generic tx98       **/99      [key: string]: SubmittableExtrinsicFunction<ApiType>;100    };101    charging: {102      /**103       * Generic tx104       **/105      [key: string]: SubmittableExtrinsicFunction<ApiType>;106    };107    configuration: {108      setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;109      setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u32> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;110      /**111       * Generic tx112       **/113      [key: string]: SubmittableExtrinsicFunction<ApiType>;114    };115    cumulusXcm: {116      /**117       * Generic tx118       **/119      [key: string]: SubmittableExtrinsicFunction<ApiType>;120    };121    dmpQueue: {122      /**123       * Service a single overweight message.124       * 125       * - `origin`: Must pass `ExecuteOverweightOrigin`.126       * - `index`: The index of the overweight message to service.127       * - `weight_limit`: The amount of weight that message execution may take.128       * 129       * Errors:130       * - `Unknown`: Message of `index` is unknown.131       * - `OverLimit`: Message execution may use greater than `weight_limit`.132       * 133       * Events:134       * - `OverweightServiced`: On success.135       **/136      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;137      /**138       * Generic tx139       **/140      [key: string]: SubmittableExtrinsicFunction<ApiType>;141    };142    ethereum: {143      /**144       * Transact an Ethereum transaction.145       **/146      transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;147      /**148       * Generic tx149       **/150      [key: string]: SubmittableExtrinsicFunction<ApiType>;151    };152    evm: {153      /**154       * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.155       **/156      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 | object | string | Uint8Array, nonce: Option<U256> | null | object | string | Uint8Array, 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>]>>]>;157      /**158       * Issue an EVM create operation. This is similar to a contract creation transaction in159       * Ethereum.160       **/161      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 | object | string | Uint8Array, nonce: Option<U256> | null | object | string | Uint8Array, 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>]>>]>;162      /**163       * Issue an EVM create2 operation.164       **/165      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 | object | string | Uint8Array, nonce: Option<U256> | null | object | string | Uint8Array, 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>]>>]>;166      /**167       * Withdraw balance from EVM into currency/balances pallet.168       **/169      withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;170      /**171       * Generic tx172       **/173      [key: string]: SubmittableExtrinsicFunction<ApiType>;174    };175    evmMigration: {176      begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;177      finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;178      setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;179      /**180       * Generic tx181       **/182      [key: string]: SubmittableExtrinsicFunction<ApiType>;183    };184    foreingAssets: {185      registerForeignAsset: AugmentedSubmittable<(owner: AccountId32 | string | Uint8Array, location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, metadata: PalletForeingAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, XcmVersionedMultiLocation, PalletForeingAssetsModuleAssetMetadata]>;186      updateForeignAsset: AugmentedSubmittable<(foreignAssetId: u32 | AnyNumber | Uint8Array, location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, metadata: PalletForeingAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, XcmVersionedMultiLocation, PalletForeingAssetsModuleAssetMetadata]>;187      /**188       * Generic tx189       **/190      [key: string]: SubmittableExtrinsicFunction<ApiType>;191    };192    inflation: {193      /**194       * This method sets the inflation start date. Can be only called once.195       * Inflation start block can be backdated and will catch up. The method will create Treasury196       * account if it does not exist and perform the first inflation deposit.197       * 198       * # Permissions199       * 200       * * Root201       * 202       * # Arguments203       * 204       * * inflation_start_relay_block: The relay chain block at which inflation should start205       **/206      startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;207      /**208       * Generic tx209       **/210      [key: string]: SubmittableExtrinsicFunction<ApiType>;211    };212    parachainSystem: {213      authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;214      enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;215      /**216       * Set the current validation data.217       * 218       * This should be invoked exactly once per block. It will panic at the finalization219       * phase if the call was not invoked.220       * 221       * The dispatch origin for this call must be `Inherent`222       * 223       * As a side effect, this function upgrades the current validation function224       * if the appropriate time has come.225       **/226      setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;227      sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;228      /**229       * Generic tx230       **/231      [key: string]: SubmittableExtrinsicFunction<ApiType>;232    };233    polkadotXcm: {234      /**235       * Execute an XCM message from a local, signed, origin.236       * 237       * An event is deposited indicating whether `msg` could be executed completely or only238       * partially.239       * 240       * No more than `max_weight` will be used in its attempted execution. If this is less than the241       * maximum amount of weight that the message could take to be executed, then no execution242       * attempt will be made.243       * 244       * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully245       * to completion; only that *some* of it was executed.246       **/247      execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;248      /**249       * Set a safe XCM version (the version that XCM should be encoded with if the most recent250       * version a destination can accept is unknown).251       * 252       * - `origin`: Must be Root.253       * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.254       **/255      forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;256      /**257       * Ask a location to notify us regarding their XCM version and any changes to it.258       * 259       * - `origin`: Must be Root.260       * - `location`: The location to which we should subscribe for XCM version notifications.261       **/262      forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;263      /**264       * Require that a particular destination should no longer notify us regarding any XCM265       * version changes.266       * 267       * - `origin`: Must be Root.268       * - `location`: The location to which we are currently subscribed for XCM version269       * notifications which we no longer desire.270       **/271      forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;272      /**273       * Extoll that a particular destination can be communicated with through a particular274       * version of XCM.275       * 276       * - `origin`: Must be Root.277       * - `location`: The destination that is being described.278       * - `xcm_version`: The latest version of XCM that `location` supports.279       **/280      forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;281      /**282       * Transfer some assets from the local chain to the sovereign account of a destination283       * chain and forward a notification XCM.284       * 285       * Fee payment on the destination side is made from the asset in the `assets` vector of286       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight287       * is needed than `weight_limit`, then the operation will fail and the assets send may be288       * at risk.289       * 290       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.291       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send292       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.293       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be294       * an `AccountId32` value.295       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the296       * `dest` side.297       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay298       * fees.299       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.300       **/301      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]>;302      /**303       * Teleport some assets from the local chain to some destination chain.304       * 305       * Fee payment on the destination side is made from the asset in the `assets` vector of306       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight307       * is needed than `weight_limit`, then the operation will fail and the assets send may be308       * at risk.309       * 310       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.311       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send312       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.313       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be314       * an `AccountId32` value.315       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the316       * `dest` side. May not be empty.317       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay318       * fees.319       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.320       **/321      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]>;322      /**323       * Transfer some assets from the local chain to the sovereign account of a destination324       * chain and forward a notification XCM.325       * 326       * Fee payment on the destination side is made from the asset in the `assets` vector of327       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,328       * with all fees taken as needed from the asset.329       * 330       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.331       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send332       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.333       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be334       * an `AccountId32` value.335       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the336       * `dest` side.337       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay338       * fees.339       **/340      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]>;341      send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;342      /**343       * Teleport some assets from the local chain to some destination chain.344       * 345       * Fee payment on the destination side is made from the asset in the `assets` vector of346       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,347       * with all fees taken as needed from the asset.348       * 349       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.350       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send351       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.352       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be353       * an `AccountId32` value.354       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the355       * `dest` side. May not be empty.356       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay357       * fees.358       **/359      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]>;360      /**361       * Generic tx362       **/363      [key: string]: SubmittableExtrinsicFunction<ApiType>;364    };365    rmrkCore: {366      /**367       * Accept an NFT sent from another account to self or an owned NFT.368       * 369       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.370       * 371       * # Permissions:372       * - Token-owner-to-be373       * 374       * # Arguments:375       * - `origin`: sender of the transaction376       * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.377       * - `rmrk_nft_id`: ID of the NFT to be accepted.378       * - `new_owner`: Either the sender's account ID or a sender-owned NFT,379       * whichever the accepted NFT was sent to.380       **/381      acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;382      /**383       * Accept the addition of a newly created pending resource to an existing NFT.384       * 385       * This transaction is needed when a resource is created and assigned to an NFT386       * by a non-owner, i.e. the collection issuer, with one of the387       * [`add_...` transactions](Pallet::add_basic_resource).388       * 389       * # Permissions:390       * - Token owner391       * 392       * # Arguments:393       * - `origin`: sender of the transaction394       * - `rmrk_collection_id`: RMRK collection ID of the NFT.395       * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.396       * - `resource_id`: ID of the newly created pending resource.397       * accept the addition of a new resource to an existing NFT398       **/399      acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;400      /**401       * Accept the removal of a removal-pending resource from an NFT.402       * 403       * This transaction is needed when a non-owner, i.e. the collection issuer,404       * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.405       * 406       * # Permissions:407       * - Token owner408       * 409       * # Arguments:410       * - `origin`: sender of the transaction411       * - `rmrk_collection_id`: RMRK collection ID of the NFT.412       * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.413       * - `resource_id`: ID of the removal-pending resource.414       **/415      acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;416      /**417       * Create and set/propose a basic resource for an NFT.418       * 419       * A basic resource is the simplest, lacking a Base and anything that comes with it.420       * See RMRK docs for more information and examples.421       * 422       * # Permissions:423       * - Collection issuer - if not the token owner, adding the resource will warrant424       * the owner's [acceptance](Pallet::accept_resource).425       * 426       * # Arguments:427       * - `origin`: sender of the transaction428       * - `rmrk_collection_id`: RMRK collection ID of the NFT.429       * - `nft_id`: ID of the NFT to assign a resource to.430       * - `resource`: Data of the resource to be created.431       **/432      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]>;433      /**434       * Create and set/propose a composable resource for an NFT.435       * 436       * A composable resource links to a Base and has a subset of its Parts it is composed of.437       * See RMRK docs for more information and examples.438       * 439       * # Permissions:440       * - Collection issuer - if not the token owner, adding the resource will warrant441       * the owner's [acceptance](Pallet::accept_resource).442       * 443       * # Arguments:444       * - `origin`: sender of the transaction445       * - `rmrk_collection_id`: RMRK collection ID of the NFT.446       * - `nft_id`: ID of the NFT to assign a resource to.447       * - `resource`: Data of the resource to be created.448       **/449      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]>;450      /**451       * Create and set/propose a slot resource for an NFT.452       * 453       * A slot resource links to a Base and a slot ID in it which it can fit into.454       * See RMRK docs for more information and examples.455       * 456       * # Permissions:457       * - Collection issuer - if not the token owner, adding the resource will warrant458       * the owner's [acceptance](Pallet::accept_resource).459       * 460       * # Arguments:461       * - `origin`: sender of the transaction462       * - `rmrk_collection_id`: RMRK collection ID of the NFT.463       * - `nft_id`: ID of the NFT to assign a resource to.464       * - `resource`: Data of the resource to be created.465       **/466      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]>;467      /**468       * Burn an NFT, destroying it and its nested tokens up to the specified limit.469       * If the burning budget is exceeded, the transaction is reverted.470       * 471       * This is the way to burn a nested token as well.472       * 473       * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).474       * 475       * # Permissions:476       * * Token owner477       * 478       * # Arguments:479       * - `origin`: sender of the transaction480       * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.481       * - `nft_id`: ID of the NFT to be destroyed.482       * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction483       * is reverted if there are more tokens to burn in the nesting tree than this number.484       * This is primarily a mechanism of transaction weight control.485       **/486      burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;487      /**488       * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).489       * 490       * # Permissions:491       * * Collection issuer492       * 493       * # Arguments:494       * - `origin`: sender of the transaction495       * - `collection_id`: RMRK collection ID to change the issuer of.496       * - `new_issuer`: Collection's new issuer.497       **/498      changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;499      /**500       * Create a new collection of NFTs.501       * 502       * # Permissions:503       * * Anyone - will be assigned as the issuer of the collection.504       * 505       * # Arguments:506       * - `origin`: sender of the transaction507       * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.508       * - `max`: Optional maximum number of tokens.509       * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.510       * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.511       **/512      createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | object | string | Uint8Array, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;513      /**514       * Destroy a collection.515       * 516       * Only empty collections can be destroyed. If it has any tokens, they must be burned first.517       * 518       * # Permissions:519       * * Collection issuer520       * 521       * # Arguments:522       * - `origin`: sender of the transaction523       * - `collection_id`: RMRK ID of the collection to destroy.524       **/525      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;526      /**527       * "Lock" the collection and prevent new token creation. Cannot be undone.528       * 529       * # Permissions:530       * * Collection issuer531       * 532       * # Arguments:533       * - `origin`: sender of the transaction534       * - `collection_id`: RMRK ID of the collection to lock.535       **/536      lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;537      /**538       * Mint an NFT in a specified collection.539       * 540       * # Permissions:541       * * Collection issuer542       * 543       * # Arguments:544       * - `origin`: sender of the transaction545       * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).546       * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.547       * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.548       * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.549       * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.550       * - `transferable`: Can this NFT be transferred? Cannot be changed.551       * - `resources`: Resource data to be added to the NFT immediately after minting.552       **/553      mintNft: AugmentedSubmittable<(owner: Option<AccountId32> | null | object | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, recipient: Option<AccountId32> | null | object | string | Uint8Array, royaltyAmount: Option<Permill> | null | object | string | Uint8Array, metadata: Bytes | string | Uint8Array, transferable: bool | boolean | Uint8Array, resources: Option<Vec<RmrkTraitsResourceResourceTypes>> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<AccountId32>, u32, Option<AccountId32>, Option<Permill>, Bytes, bool, Option<Vec<RmrkTraitsResourceResourceTypes>>]>;554      /**555       * Reject an NFT sent from another account to self or owned NFT.556       * The NFT in question will not be sent back and burnt instead.557       * 558       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.559       * 560       * # Permissions:561       * - Token-owner-to-be-not562       * 563       * # Arguments:564       * - `origin`: sender of the transaction565       * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.566       * - `rmrk_nft_id`: ID of the NFT to be rejected.567       **/568      rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;569      /**570       * Remove and erase a resource from an NFT.571       * 572       * If the sender does not own the NFT, then it will be pending confirmation,573       * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.574       * 575       * # Permissions576       * - Collection issuer577       * 578       * # Arguments579       * - `origin`: sender of the transaction580       * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.581       * - `nft_id`: ID of the NFT with a resource to be removed.582       * - `resource_id`: ID of the resource to be removed.583       **/584      removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;585      /**586       * Transfer an NFT from an account/NFT A to another account/NFT B.587       * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].588       * 589       * If the target owner is an NFT owned by another account, then the NFT will enter590       * the pending state and will have to be accepted by the other account.591       * 592       * # Permissions:593       * - Token owner594       * 595       * # Arguments:596       * - `origin`: sender of the transaction597       * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.598       * - `rmrk_nft_id`: ID of the NFT to be transferred.599       * - `new_owner`: New owner of the nft which can be either an account or a NFT.600       **/601      send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;602      /**603       * Set a different order of resource priorities for an NFT. Priorities can be used,604       * for example, for order of rendering.605       * 606       * Note that the priorities are not updated automatically, and are an empty vector607       * by default. There is no pre-set definition for the order to be particular,608       * it can be interpreted arbitrarily use-case by use-case.609       * 610       * # Permissions:611       * - Token owner612       * 613       * # Arguments:614       * - `origin`: sender of the transaction615       * - `rmrk_collection_id`: RMRK collection ID of the NFT.616       * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.617       * - `priorities`: Ordered vector of resource IDs.618       **/619      setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;620      /**621       * Add or edit a custom user property, a key-value pair, describing the metadata622       * of a token or a collection, on either one of these.623       * 624       * Note that in this proxy implementation many details regarding RMRK are stored625       * as scoped properties prefixed with "rmrk:", normally inaccessible626       * to external transactions and RPCs.627       * 628       * # Permissions:629       * - Collection issuer - in case of collection property630       * - Token owner - in case of NFT property631       * 632       * # Arguments:633       * - `origin`: sender of the transaction634       * - `rmrk_collection_id`: RMRK collection ID.635       * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.636       * - `key`: Key of the custom property to be referenced by.637       * - `value`: Value of the custom property to be stored.638       **/639      setProperty: AugmentedSubmittable<(rmrkCollectionId: Compact<u32> | AnyNumber | Uint8Array, maybeNftId: Option<u32> | null | object | string | Uint8Array, key: Bytes | string | Uint8Array, value: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Option<u32>, Bytes, Bytes]>;640      /**641       * Generic tx642       **/643      [key: string]: SubmittableExtrinsicFunction<ApiType>;644    };645    rmrkEquip: {646      /**647       * Create a new Base.648       * 649       * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)650       * 651       * # Permissions652       * - Anyone - will be assigned as the issuer of the Base.653       * 654       * # Arguments:655       * - `origin`: Caller, will be assigned as the issuer of the Base656       * - `base_type`: Arbitrary media type, e.g. "svg".657       * - `symbol`: Arbitrary client-chosen symbol.658       * - `parts`: Array of Fixed and Slot Parts composing the Base,659       * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).660       **/661      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>]>;662      /**663       * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.664       * 665       * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).666       * 667       * # Permissions:668       * - Base issuer669       * 670       * # Arguments:671       * - `origin`: sender of the transaction672       * - `base_id`: Base containing the Slot Part to be updated.673       * - `slot_id`: Slot Part whose Equippable List is being updated .674       * - `equippables`: List of equippables that will override the current Equippables list.675       **/676      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]>;677      /**678       * Add a Theme to a Base.679       * A Theme named "default" is required prior to adding other Themes.680       * 681       * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).682       * 683       * # Permissions:684       * - Base issuer685       * 686       * # Arguments:687       * - `origin`: sender of the transaction688       * - `base_id`: Base ID containing the Theme to be updated.689       * - `theme`: Theme to add to the Base.  A Theme has a name and properties, which are an690       * array of [key, value, inherit].691       * - `key`: Arbitrary BoundedString, defined by client.692       * - `value`: Arbitrary BoundedString, defined by client.693       * - `inherit`: Optional bool.694       **/695      themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;696      /**697       * Generic tx698       **/699      [key: string]: SubmittableExtrinsicFunction<ApiType>;700    };701    scheduler: {702      /**703       * Cancel a named scheduled task.704       **/705      cancelNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed]>;706      /**707       * Schedule a named task.708       **/709      scheduleNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | object | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, FrameSupportScheduleMaybeHashed]>;710      /**711       * Schedule a named task after a delay.712       * 713       * # <weight>714       * Same as [`schedule_named`](Self::schedule_named).715       * # </weight>716       **/717      scheduleNamedAfter: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | object | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, FrameSupportScheduleMaybeHashed]>;718      /**719       * Generic tx720       **/721      [key: string]: SubmittableExtrinsicFunction<ApiType>;722    };723    structure: {724      /**725       * Generic tx726       **/727      [key: string]: SubmittableExtrinsicFunction<ApiType>;728    };729    sudo: {730      /**731       * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo732       * key.733       * 734       * The dispatch origin for this call must be _Signed_.735       * 736       * # <weight>737       * - O(1).738       * - Limited storage reads.739       * - One DB change.740       * # </weight>741       **/742      setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;743      /**744       * Authenticates the sudo key and dispatches a function call with `Root` origin.745       * 746       * The dispatch origin for this call must be _Signed_.747       * 748       * # <weight>749       * - O(1).750       * - Limited storage reads.751       * - One DB write (event).752       * - Weight of derivative `call` execution + 10,000.753       * # </weight>754       **/755      sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;756      /**757       * Authenticates the sudo key and dispatches a function call with `Signed` origin from758       * a given account.759       * 760       * The dispatch origin for this call must be _Signed_.761       * 762       * # <weight>763       * - O(1).764       * - Limited storage reads.765       * - One DB write (event).766       * - Weight of derivative `call` execution + 10,000.767       * # </weight>768       **/769      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]>;770      /**771       * Authenticates the sudo key and dispatches a function call with `Root` origin.772       * This function does not check the weight of the call, and instead allows the773       * Sudo user to specify the weight of the call.774       * 775       * The dispatch origin for this call must be _Signed_.776       * 777       * # <weight>778       * - O(1).779       * - The weight of this call is defined by the caller.780       * # </weight>781       **/782      sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, u64]>;783      /**784       * Generic tx785       **/786      [key: string]: SubmittableExtrinsicFunction<ApiType>;787    };788    system: {789      /**790       * A dispatch that will fill the block weight up to the given ratio.791       **/792      fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;793      /**794       * Kill all storage items with a key that starts with the given prefix.795       * 796       * **NOTE:** We rely on the Root origin to provide us the number of subkeys under797       * the prefix we are removing to accurately calculate the weight of this function.798       **/799      killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;800      /**801       * Kill some items from storage.802       **/803      killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;804      /**805       * Make some on-chain remark.806       * 807       * # <weight>808       * - `O(1)`809       * # </weight>810       **/811      remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;812      /**813       * Make some on-chain remark and emit event.814       **/815      remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;816      /**817       * Set the new runtime code.818       * 819       * # <weight>820       * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`821       * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is822       * expensive).823       * - 1 storage write (codec `O(C)`).824       * - 1 digest item.825       * - 1 event.826       * The weight of this function is dependent on the runtime, but generally this is very827       * expensive. We will treat this as a full block.828       * # </weight>829       **/830      setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;831      /**832       * Set the new runtime code without doing any checks of the given `code`.833       * 834       * # <weight>835       * - `O(C)` where `C` length of `code`836       * - 1 storage write (codec `O(C)`).837       * - 1 digest item.838       * - 1 event.839       * The weight of this function is dependent on the runtime. We will treat this as a full840       * block. # </weight>841       **/842      setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;843      /**844       * Set the number of pages in the WebAssembly environment's heap.845       **/846      setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;847      /**848       * Set some items of storage.849       **/850      setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;851      /**852       * Generic tx853       **/854      [key: string]: SubmittableExtrinsicFunction<ApiType>;855    };856    timestamp: {857      /**858       * Set the current time.859       * 860       * This call should be invoked exactly once per block. It will panic at the finalization861       * phase, if this call hasn't been invoked by that time.862       * 863       * The timestamp should be greater than the previous one by the amount specified by864       * `MinimumPeriod`.865       * 866       * The dispatch origin for this call must be `Inherent`.867       * 868       * # <weight>869       * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)870       * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in871       * `on_finalize`)872       * - 1 event handler `on_timestamp_set`. Must be `O(1)`.873       * # </weight>874       **/875      set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;876      /**877       * Generic tx878       **/879      [key: string]: SubmittableExtrinsicFunction<ApiType>;880    };881    tokens: {882      /**883       * Exactly as `transfer`, except the origin must be root and the source884       * account may be specified.885       * 886       * The dispatch origin for this call must be _Root_.887       * 888       * - `source`: The sender of the transfer.889       * - `dest`: The recipient of the transfer.890       * - `currency_id`: currency type.891       * - `amount`: free balance amount to tranfer.892       **/893      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: PalletForeingAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, PalletForeingAssetsAssetIds, Compact<u128>]>;894      /**895       * Set the balances of a given account.896       * 897       * This will alter `FreeBalance` and `ReservedBalance` in storage. it898       * will also decrease the total issuance of the system899       * (`TotalIssuance`). If the new free or reserved balance is below the900       * existential deposit, it will reap the `AccountInfo`.901       * 902       * The dispatch origin for this call is `root`.903       **/904      setBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeingAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, newReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeingAssetsAssetIds, Compact<u128>, Compact<u128>]>;905      /**906       * Transfer some liquid free balance to another account.907       * 908       * `transfer` will set the `FreeBalance` of the sender and receiver.909       * It will decrease the total issuance of the system by the910       * `TransferFee`. If the sender's account is below the existential911       * deposit as a result of the transfer, the account will be reaped.912       * 913       * The dispatch origin for this call must be `Signed` by the914       * transactor.915       * 916       * - `dest`: The recipient of the transfer.917       * - `currency_id`: currency type.918       * - `amount`: free balance amount to tranfer.919       **/920      transfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeingAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeingAssetsAssetIds, Compact<u128>]>;921      /**922       * Transfer all remaining balance to the given account.923       * 924       * NOTE: This function only attempts to transfer _transferable_925       * balances. This means that any locked, reserved, or existential926       * deposits (when `keep_alive` is `true`), will not be transferred by927       * this function. To ensure that this function results in a killed928       * account, you might need to prepare the account by removing any929       * reference counters, storage deposits, etc...930       * 931       * The dispatch origin for this call must be `Signed` by the932       * transactor.933       * 934       * - `dest`: The recipient of the transfer.935       * - `currency_id`: currency type.936       * - `keep_alive`: A boolean to determine if the `transfer_all`937       * operation should send all of the funds the account has, causing938       * the sender account to be killed (false), or transfer everything939       * except at least the existential deposit, which will guarantee to940       * keep the sender account alive (true).941       **/942      transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeingAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeingAssetsAssetIds, bool]>;943      /**944       * Same as the [`transfer`] call, but with a check that the transfer945       * will not kill the origin account.946       * 947       * 99% of the time you want [`transfer`] instead.948       * 949       * The dispatch origin for this call must be `Signed` by the950       * transactor.951       * 952       * - `dest`: The recipient of the transfer.953       * - `currency_id`: currency type.954       * - `amount`: free balance amount to tranfer.955       **/956      transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeingAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeingAssetsAssetIds, Compact<u128>]>;957      /**958       * Generic tx959       **/960      [key: string]: SubmittableExtrinsicFunction<ApiType>;961    };962    treasury: {963      /**964       * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary965       * and the original deposit will be returned.966       * 967       * May only be called from `T::ApproveOrigin`.968       * 969       * # <weight>970       * - Complexity: O(1).971       * - DbReads: `Proposals`, `Approvals`972       * - DbWrite: `Approvals`973       * # </weight>974       **/975      approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;976      /**977       * Put forward a suggestion for spending. A deposit proportional to the value978       * is reserved and slashed if the proposal is rejected. It is returned once the979       * proposal is awarded.980       * 981       * # <weight>982       * - Complexity: O(1)983       * - DbReads: `ProposalCount`, `origin account`984       * - DbWrites: `ProposalCount`, `Proposals`, `origin account`985       * # </weight>986       **/987      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]>;988      /**989       * Reject a proposed spend. The original deposit will be slashed.990       * 991       * May only be called from `T::RejectOrigin`.992       * 993       * # <weight>994       * - Complexity: O(1)995       * - DbReads: `Proposals`, `rejected proposer account`996       * - DbWrites: `Proposals`, `rejected proposer account`997       * # </weight>998       **/999      rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1000      /**1001       * Force a previously approved proposal to be removed from the approval queue.1002       * The original deposit will no longer be returned.1003       * 1004       * May only be called from `T::RejectOrigin`.1005       * - `proposal_id`: The index of a proposal1006       * 1007       * # <weight>1008       * - Complexity: O(A) where `A` is the number of approvals1009       * - Db reads and writes: `Approvals`1010       * # </weight>1011       * 1012       * Errors:1013       * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1014       * i.e., the proposal has not been approved. This could also mean the proposal does not1015       * exist altogether, thus there is no way it would have been approved in the first place.1016       **/1017      removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1018      /**1019       * Propose and approve a spend of treasury funds.1020       * 1021       * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1022       * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1023       * - `beneficiary`: The destination account for the transfer.1024       * 1025       * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1026       * beneficiary.1027       **/1028      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]>;1029      /**1030       * Generic tx1031       **/1032      [key: string]: SubmittableExtrinsicFunction<ApiType>;1033    };1034    unique: {1035      /**1036       * Add an admin to a collection.1037       * 1038       * NFT Collection can be controlled by multiple admin addresses1039       * (some which can also be servers, for example). Admins can issue1040       * and burn NFTs, as well as add and remove other admins,1041       * but cannot change NFT or Collection ownership.1042       * 1043       * # Permissions1044       * 1045       * * Collection owner1046       * * Collection admin1047       * 1048       * # Arguments1049       * 1050       * * `collection_id`: ID of the Collection to add an admin for.1051       * * `new_admin`: Address of new admin to add.1052       **/1053      addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1054      /**1055       * Add an address to allow list.1056       * 1057       * # Permissions1058       * 1059       * * Collection owner1060       * * Collection admin1061       * 1062       * # Arguments1063       * 1064       * * `collection_id`: ID of the modified collection.1065       * * `address`: ID of the address to be added to the allowlist.1066       **/1067      addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1068      /**1069       * Allow a non-permissioned address to transfer or burn an item.1070       * 1071       * # Permissions1072       * 1073       * * Collection owner1074       * * Collection admin1075       * * Current item owner1076       * 1077       * # Arguments1078       * 1079       * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1080       * * `collection_id`: ID of the collection the item belongs to.1081       * * `item_id`: ID of the item transactions on which are now approved.1082       * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1083       * Set to 0 to revoke the approval.1084       **/1085      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]>;1086      /**1087       * Destroy a token on behalf of the owner as a non-owner account.1088       * 1089       * See also: [`approve`][`Pallet::approve`].1090       * 1091       * After this method executes, one approval is removed from the total so that1092       * the approved address will not be able to transfer this item again from this owner.1093       * 1094       * # Permissions1095       * 1096       * * Collection owner1097       * * Collection admin1098       * * Current token owner1099       * * Address approved by current item owner1100       * 1101       * # Arguments1102       * 1103       * * `from`: The owner of the burning item.1104       * * `collection_id`: ID of the collection to which the item belongs.1105       * * `item_id`: ID of item to burn.1106       * * `value`: Number of pieces to burn.1107       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1108       * * Fungible Mode: The desired number of pieces to burn.1109       * * Re-Fungible Mode: The desired number of pieces to burn.1110       **/1111      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]>;1112      /**1113       * Destroy an item.1114       * 1115       * # Permissions1116       * 1117       * * Collection owner1118       * * Collection admin1119       * * Current item owner1120       * 1121       * # Arguments1122       * 1123       * * `collection_id`: ID of the collection to which the item belongs.1124       * * `item_id`: ID of item to burn.1125       * * `value`: Number of pieces of the item to destroy.1126       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1127       * * Fungible Mode: The desired number of pieces to burn.1128       * * Re-Fungible Mode: The desired number of pieces to burn.1129       **/1130      burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1131      /**1132       * Change the owner of the collection.1133       * 1134       * # Permissions1135       * 1136       * * Collection owner1137       * 1138       * # Arguments1139       * 1140       * * `collection_id`: ID of the modified collection.1141       * * `new_owner`: ID of the account that will become the owner.1142       **/1143      changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1144      /**1145       * Confirm own sponsorship of a collection, becoming the sponsor.1146       * 1147       * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1148       * Sponsor can pay the fees of a transaction instead of the sender,1149       * but only within specified limits.1150       * 1151       * # Permissions1152       * 1153       * * Sponsor-to-be1154       * 1155       * # Arguments1156       * 1157       * * `collection_id`: ID of the collection with the pending sponsor.1158       **/1159      confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1160      /**1161       * Create a collection of tokens.1162       * 1163       * Each Token may have multiple properties encoded as an array of bytes1164       * of certain length. The initial owner of the collection is set1165       * to the address that signed the transaction and can be changed later.1166       * 1167       * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1168       * 1169       * # Permissions1170       * 1171       * * Anyone - becomes the owner of the new collection.1172       * 1173       * # Arguments1174       * 1175       * * `collection_name`: Wide-character string with collection name1176       * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1177       * * `collection_description`: Wide-character string with collection description1178       * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1179       * * `token_prefix`: Byte string containing the token prefix to mark a collection1180       * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1181       * * `mode`: Type of items stored in the collection and type dependent data.1182       **/1183      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]>;1184      /**1185       * Create a collection with explicit parameters.1186       * 1187       * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1188       * 1189       * # Permissions1190       * 1191       * * Anyone - becomes the owner of the new collection.1192       * 1193       * # Arguments1194       * 1195       * * `data`: Explicit data of a collection used for its creation.1196       **/1197      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]>;1198      /**1199       * Mint an item within a collection.1200       * 1201       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1202       * 1203       * # Permissions1204       * 1205       * * Collection owner1206       * * Collection admin1207       * * Anyone if1208       * * Allow List is enabled, and1209       * * Address is added to allow list, and1210       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1211       * 1212       * # Arguments1213       * 1214       * * `collection_id`: ID of the collection to which an item would belong.1215       * * `owner`: Address of the initial owner of the item.1216       * * `data`: Token data describing the item to store on chain.1217       **/1218      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]>;1219      /**1220       * Create multiple items 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 the 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 the tokens would belong.1236       * * `owner`: Address of the initial owner of the tokens.1237       * * `items_data`: Vector of data describing each item to be created.1238       **/1239      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>]>;1240      /**1241       * Create multiple items within a collection with explicitly specified initial parameters.1242       * 1243       * # Permissions1244       * 1245       * * Collection owner1246       * * Collection admin1247       * * Anyone if1248       * * Allow List is enabled, and1249       * * Address is added to allow list, and1250       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1251       * 1252       * # Arguments1253       * 1254       * * `collection_id`: ID of the collection to which the tokens would belong.1255       * * `data`: Explicit item creation data.1256       **/1257      createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1258      /**1259       * Delete specified collection properties.1260       * 1261       * # Permissions1262       * 1263       * * Collection Owner1264       * * Collection Admin1265       * 1266       * # Arguments1267       * 1268       * * `collection_id`: ID of the modified collection.1269       * * `property_keys`: Vector of keys of the properties to be deleted.1270       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1271       **/1272      deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1273      /**1274       * Delete specified token properties. Currently properties only work with NFTs.1275       * 1276       * # Permissions1277       * 1278       * * Depends on collection's token property permissions and specified property mutability:1279       * * Collection owner1280       * * Collection admin1281       * * Token owner1282       * 1283       * # Arguments1284       * 1285       * * `collection_id`: ID of the collection to which the token belongs.1286       * * `token_id`: ID of the modified token.1287       * * `property_keys`: Vector of keys of the properties to be deleted.1288       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1289       **/1290      deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1291      /**1292       * Destroy a collection if no tokens exist within.1293       * 1294       * # Permissions1295       * 1296       * * Collection owner1297       * 1298       * # Arguments1299       * 1300       * * `collection_id`: Collection to destroy.1301       **/1302      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1303      /**1304       * Remove admin of a collection.1305       * 1306       * An admin address can remove itself. List of admins may become empty,1307       * in which case only Collection Owner will be able to add an Admin.1308       * 1309       * # Permissions1310       * 1311       * * Collection owner1312       * * Collection admin1313       * 1314       * # Arguments1315       * 1316       * * `collection_id`: ID of the collection to remove the admin for.1317       * * `account_id`: Address of the admin to remove.1318       **/1319      removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1320      /**1321       * Remove a collection's a sponsor, making everyone pay for their own transactions.1322       * 1323       * # Permissions1324       * 1325       * * Collection owner1326       * 1327       * # Arguments1328       * 1329       * * `collection_id`: ID of the collection with the sponsor to remove.1330       **/1331      removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1332      /**1333       * Remove an address from allow list.1334       * 1335       * # Permissions1336       * 1337       * * Collection owner1338       * * Collection admin1339       * 1340       * # Arguments1341       * 1342       * * `collection_id`: ID of the modified collection.1343       * * `address`: ID of the address to be removed from the allowlist.1344       **/1345      removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1346      /**1347       * Re-partition a refungible token, while owning all of its parts/pieces.1348       * 1349       * # Permissions1350       * 1351       * * Token owner (must own every part)1352       * 1353       * # Arguments1354       * 1355       * * `collection_id`: ID of the collection the RFT belongs to.1356       * * `token_id`: ID of the RFT.1357       * * `amount`: New number of parts/pieces into which the token shall be partitioned.1358       **/1359      repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1360      /**1361       * Set specific limits of a collection. Empty, or None fields mean chain default.1362       * 1363       * # Permissions1364       * 1365       * * Collection owner1366       * * Collection admin1367       * 1368       * # Arguments1369       * 1370       * * `collection_id`: ID of the modified collection.1371       * * `new_limit`: New limits of the collection. Fields that are not set (None)1372       * will not overwrite the old ones.1373       **/1374      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]>;1375      /**1376       * Set specific permissions of a collection. Empty, or None fields mean chain default.1377       * 1378       * # Permissions1379       * 1380       * * Collection owner1381       * * Collection admin1382       * 1383       * # Arguments1384       * 1385       * * `collection_id`: ID of the modified collection.1386       * * `new_permission`: New permissions of the collection. Fields that are not set (None)1387       * will not overwrite the old ones.1388       **/1389      setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1390      /**1391       * Add or change collection properties.1392       * 1393       * # Permissions1394       * 1395       * * Collection owner1396       * * Collection admin1397       * 1398       * # Arguments1399       * 1400       * * `collection_id`: ID of the modified collection.1401       * * `properties`: Vector of key-value pairs stored as the collection's metadata.1402       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1403       **/1404      setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1405      /**1406       * Set (invite) a new collection sponsor.1407       * 1408       * If successful, confirmation from the sponsor-to-be will be pending.1409       * 1410       * # Permissions1411       * 1412       * * Collection owner1413       * * Collection admin1414       * 1415       * # Arguments1416       * 1417       * * `collection_id`: ID of the modified collection.1418       * * `new_sponsor`: ID of the account of the sponsor-to-be.1419       **/1420      setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1421      /**1422       * Add or change token properties according to collection's permissions.1423       * Currently properties only work with NFTs.1424       * 1425       * # Permissions1426       * 1427       * * Depends on collection's token property permissions and specified property mutability:1428       * * Collection owner1429       * * Collection admin1430       * * Token owner1431       * 1432       * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1433       * 1434       * # Arguments1435       * 1436       * * `collection_id: ID of the collection to which the token belongs.1437       * * `token_id`: ID of the modified token.1438       * * `properties`: Vector of key-value pairs stored as the token's metadata.1439       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1440       **/1441      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>]>;1442      /**1443       * Add or change token property permissions of a collection.1444       * 1445       * Without a permission for a particular key, a property with that key1446       * cannot be created in a token.1447       * 1448       * # Permissions1449       * 1450       * * Collection owner1451       * * Collection admin1452       * 1453       * # Arguments1454       * 1455       * * `collection_id`: ID of the modified collection.1456       * * `property_permissions`: Vector of permissions for property keys.1457       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1458       **/1459      setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1460      /**1461       * Completely allow or disallow transfers for a particular collection.1462       * 1463       * # Permissions1464       * 1465       * * Collection owner1466       * 1467       * # Arguments1468       * 1469       * * `collection_id`: ID of the collection.1470       * * `value`: New value of the flag, are transfers allowed?1471       **/1472      setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1473      /**1474       * Change ownership of the token.1475       * 1476       * # Permissions1477       * 1478       * * Collection owner1479       * * Collection admin1480       * * Current token owner1481       * 1482       * # Arguments1483       * 1484       * * `recipient`: Address of token recipient.1485       * * `collection_id`: ID of the collection the item belongs to.1486       * * `item_id`: ID of the item.1487       * * Non-Fungible Mode: Required.1488       * * Fungible Mode: Ignored.1489       * * Re-Fungible Mode: Required.1490       * 1491       * * `value`: Amount to transfer.1492       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1493       * * Fungible Mode: The desired number of pieces to transfer.1494       * * Re-Fungible Mode: The desired number of pieces to transfer.1495       **/1496      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]>;1497      /**1498       * Change ownership of an item on behalf of the owner as a non-owner account.1499       * 1500       * See the [`approve`][`Pallet::approve`] method for additional information.1501       * 1502       * After this method executes, one approval is removed from the total so that1503       * the approved address will not be able to transfer this item again from this owner.1504       * 1505       * # Permissions1506       * 1507       * * Collection owner1508       * * Collection admin1509       * * Current item owner1510       * * Address approved by current item owner1511       * 1512       * # Arguments1513       * 1514       * * `from`: Address that currently owns the token.1515       * * `recipient`: Address of the new token-owner-to-be.1516       * * `collection_id`: ID of the collection the item.1517       * * `item_id`: ID of the item to be transferred.1518       * * `value`: Amount to transfer.1519       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1520       * * Fungible Mode: The desired number of pieces to transfer.1521       * * Re-Fungible Mode: The desired number of pieces to transfer.1522       **/1523      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]>;1524      /**1525       * Generic tx1526       **/1527      [key: string]: SubmittableExtrinsicFunction<ApiType>;1528    };1529    vesting: {1530      claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1531      claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1532      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>]>;1533      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]>;1534      /**1535       * Generic tx1536       **/1537      [key: string]: SubmittableExtrinsicFunction<ApiType>;1538    };1539    xcmpQueue: {1540      /**1541       * Resumes all XCM executions for the XCMP queue.1542       * 1543       * Note that this function doesn't change the status of the in/out bound channels.1544       * 1545       * - `origin`: Must pass `ControllerOrigin`.1546       **/1547      resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1548      /**1549       * Services a single overweight XCM.1550       * 1551       * - `origin`: Must pass `ExecuteOverweightOrigin`.1552       * - `index`: The index of the overweight XCM to service1553       * - `weight_limit`: The amount of weight that XCM execution may take.1554       * 1555       * Errors:1556       * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1557       * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1558       * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1559       * 1560       * Events:1561       * - `OverweightServiced`: On success.1562       **/1563      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1564      /**1565       * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1566       * 1567       * - `origin`: Must pass `ControllerOrigin`.1568       **/1569      suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1570      /**1571       * Overwrites the number of pages of messages which must be in the queue after which we drop any further1572       * messages from the channel.1573       * 1574       * - `origin`: Must pass `Root`.1575       * - `new`: Desired value for `QueueConfigData.drop_threshold`1576       **/1577      updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1578      /**1579       * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1580       * message sending may recommence after it has been suspended.1581       * 1582       * - `origin`: Must pass `Root`.1583       * - `new`: Desired value for `QueueConfigData.resume_threshold`1584       **/1585      updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1586      /**1587       * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1588       * suspend their sending.1589       * 1590       * - `origin`: Must pass `Root`.1591       * - `new`: Desired value for `QueueConfigData.suspend_value`1592       **/1593      updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1594      /**1595       * Overwrites the amount of remaining weight under which we stop processing messages.1596       * 1597       * - `origin`: Must pass `Root`.1598       * - `new`: Desired value for `QueueConfigData.threshold_weight`1599       **/1600      updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1601      /**1602       * Overwrites the speed to which the available weight approaches the maximum weight.1603       * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1604       * 1605       * - `origin`: Must pass `Root`.1606       * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1607       **/1608      updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1609      /**1610       * Overwrite the maximum amount of weight any individual message may consume.1611       * Messages above this weight go into the overweight queue and may only be serviced explicitly.1612       * 1613       * - `origin`: Must pass `Root`.1614       * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1615       **/1616      updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1617      /**1618       * Generic tx1619       **/1620      [key: string]: SubmittableExtrinsicFunction<ApiType>;1621    };1622    xTokens: {1623      /**1624       * Transfer native currencies.1625       * 1626       * `dest_weight` is the weight for XCM execution on the dest chain, and1627       * it would be charged from the transferred assets. If set below1628       * requirements, the execution may fail and assets wouldn't be1629       * received.1630       * 1631       * It's a no-op if any error on local XCM execution or message sending.1632       * Note sending assets out per se doesn't guarantee they would be1633       * received. Receiving depends on if the XCM message could be delivered1634       * by the network, and if the receiving chain would handle1635       * messages correctly.1636       **/1637      transfer: AugmentedSubmittable<(currencyId: PalletForeingAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeingAssetsAssetIds, u128, XcmVersionedMultiLocation, u64]>;1638      /**1639       * Transfer `MultiAsset`.1640       * 1641       * `dest_weight` is the weight for XCM execution on the dest chain, and1642       * it would be charged from the transferred assets. If set below1643       * requirements, the execution may fail and assets wouldn't be1644       * received.1645       * 1646       * It's a no-op if any error on local XCM execution or message sending.1647       * Note sending assets out per se doesn't guarantee they would be1648       * received. Receiving depends on if the XCM message could be delivered1649       * by the network, and if the receiving chain would handle1650       * messages correctly.1651       **/1652      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]>;1653      /**1654       * Transfer several `MultiAsset` specifying the item to be used as fee1655       * 1656       * `dest_weight` is the weight for XCM execution on the dest chain, and1657       * it would be charged from the transferred assets. If set below1658       * requirements, the execution may fail and assets wouldn't be1659       * received.1660       * 1661       * `fee_item` is index of the MultiAssets that we want to use for1662       * payment1663       * 1664       * It's a no-op if any error on local XCM execution or message sending.1665       * Note sending assets out per se doesn't guarantee they would be1666       * received. Receiving depends on if the XCM message could be delivered1667       * by the network, and if the receiving chain would handle1668       * messages correctly.1669       **/1670      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]>;1671      /**1672       * Transfer `MultiAsset` specifying the fee and amount as separate.1673       * 1674       * `dest_weight` is the weight for XCM execution on the dest chain, and1675       * it would be charged from the transferred assets. If set below1676       * requirements, the execution may fail and assets wouldn't be1677       * received.1678       * 1679       * `fee` is the multiasset to be spent to pay for execution in1680       * destination chain. Both fee and amount will be subtracted form the1681       * callers balance For now we only accept fee and asset having the same1682       * `MultiLocation` id.1683       * 1684       * If `fee` is not high enough to cover for the execution costs in the1685       * destination chain, then the assets will be trapped in the1686       * destination chain1687       * 1688       * It's a no-op if any error on local XCM execution or message sending.1689       * Note sending assets out per se doesn't guarantee they would be1690       * received. Receiving depends on if the XCM message could be delivered1691       * by the network, and if the receiving chain would handle1692       * messages correctly.1693       **/1694      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]>;1695      /**1696       * Transfer several currencies specifying the item to be used as fee1697       * 1698       * `dest_weight` is the weight for XCM execution on the dest chain, and1699       * it would be charged from the transferred assets. If set below1700       * requirements, the execution may fail and assets wouldn't be1701       * received.1702       * 1703       * `fee_item` is index of the currencies tuple that we want to use for1704       * payment1705       * 1706       * It's a no-op if any error on local XCM execution or message sending.1707       * Note sending assets out per se doesn't guarantee they would be1708       * received. Receiving depends on if the XCM message could be delivered1709       * by the network, and if the receiving chain would handle1710       * messages correctly.1711       **/1712      transferMulticurrencies: AugmentedSubmittable<(currencies: Vec<ITuple<[PalletForeingAssetsAssetIds, u128]>> | ([PalletForeingAssetsAssetIds | { 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<[PalletForeingAssetsAssetIds, u128]>>, u32, XcmVersionedMultiLocation, u64]>;1713      /**1714       * Transfer native currencies specifying the fee and amount as1715       * separate.1716       * 1717       * `dest_weight` is the weight for XCM execution on the dest chain, and1718       * it would be charged from the transferred assets. If set below1719       * requirements, the execution may fail and assets wouldn't be1720       * received.1721       * 1722       * `fee` is the amount to be spent to pay for execution in destination1723       * chain. Both fee and amount will be subtracted form the callers1724       * balance.1725       * 1726       * If `fee` is not high enough to cover for the execution costs in the1727       * destination chain, then the assets will be trapped in the1728       * destination chain1729       * 1730       * It's a no-op if any error on local XCM execution or message sending.1731       * Note sending assets out per se doesn't guarantee they would be1732       * received. Receiving depends on if the XCM message could be delivered1733       * by the network, and if the receiving chain would handle1734       * messages correctly.1735       **/1736      transferWithFee: AugmentedSubmittable<(currencyId: PalletForeingAssetsAssetIds | { 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>, [PalletForeingAssetsAssetIds, u128, u128, XcmVersionedMultiLocation, u64]>;1737      /**1738       * Generic tx1739       **/1740      [key: string]: SubmittableExtrinsicFunction<ApiType>;1741    };1742  } // AugmentedSubmittables1743} // declare module