1// Auto-generated via `yarn polkadot-types-from-chain`, do not edit2/* eslint-disable */34// import type lookup before we augment - in some environments5// this is required to allow for ambient/previous definitions6import '@polkadot/api-base/types/submittable';78import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types';9import type { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';10import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';11import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill } from '@polkadot/types/interfaces/runtime';12import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumLog, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletConfigurationAppPromotionConfiguration, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, SpWeightsWeightV2Weight, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';1314export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;15export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;16export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;1718declare module '@polkadot/api-base/types/submittable' {19 interface AugmentedSubmittables<ApiType extends ApiTypes> {20 appPromotion: {21 /**22 * Recalculates interest for the specified number of stakers.23 * If all stakers are not recalculated, the next call of the extrinsic24 * will continue the recalculation, from those stakers for whom this25 * was not perform in last call.26 * 27 * # Permissions28 * 29 * * Pallet admin30 * 31 * # Arguments32 * 33 * * `stakers_number`: the number of stakers for which recalculation will be performed34 **/35 payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;36 /**37 * Sets an address as the the admin.38 * 39 * # Permissions40 * 41 * * Sudo42 * 43 * # Arguments44 * 45 * * `admin`: account of the new admin.46 **/47 setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;48 /**49 * Sets the pallet to be the sponsor for the collection.50 * 51 * # Permissions52 * 53 * * Pallet admin54 * 55 * # Arguments56 * 57 * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`58 **/59 sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;60 /**61 * Sets the pallet to be the sponsor for the contract.62 * 63 * # Permissions64 * 65 * * Pallet admin66 * 67 * # Arguments68 * 69 * * `contract_id`: the contract address that will be sponsored by `pallet_id`70 **/71 sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;72 /**73 * Stakes the amount of native tokens.74 * Sets `amount` to the locked state.75 * The maximum number of stakes for a staker is 10.76 * 77 * # Arguments78 * 79 * * `amount`: in native tokens.80 **/81 stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;82 /**83 * Removes the pallet as the sponsor for the collection.84 * Returns [`NoPermission`][`Error::NoPermission`]85 * if the pallet wasn't the sponsor.86 * 87 * # Permissions88 * 89 * * Pallet admin90 * 91 * # Arguments92 * 93 * * `collection_id`: ID of the collection that is sponsored by `pallet_id`94 **/95 stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;96 /**97 * Removes the pallet as the sponsor for the contract.98 * Returns [`NoPermission`][`Error::NoPermission`]99 * if the pallet wasn't the sponsor.100 * 101 * # Permissions102 * 103 * * Pallet admin104 * 105 * # Arguments106 * 107 * * `contract_id`: the contract address that is sponsored by `pallet_id`108 **/109 stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;110 /**111 * Unstakes all stakes.112 * Moves the sum of all stakes to the `reserved` state.113 * After the end of `PendingInterval` this sum becomes completely114 * free for further use.115 **/116 unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;117 /**118 * Generic tx119 **/120 [key: string]: SubmittableExtrinsicFunction<ApiType>;121 };122 balances: {123 /**124 * Exactly as `transfer`, except the origin must be root and the source account may be125 * specified.126 * # <weight>127 * - Same as transfer, but additional read and write because the source account is not128 * assumed to be in the overlay.129 * # </weight>130 **/131 forceTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, Compact<u128>]>;132 /**133 * Unreserve some balance from a user by force.134 * 135 * Can only be called by ROOT.136 **/137 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;138 /**139 * Set the balances of a given account.140 * 141 * This will alter `FreeBalance` and `ReservedBalance` in storage. it will142 * also alter the total issuance of the system (`TotalIssuance`) appropriately.143 * If the new free or reserved balance is below the existential deposit,144 * it will reset the account nonce (`frame_system::AccountNonce`).145 * 146 * The dispatch origin for this call is `root`.147 **/148 setBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, newReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>, Compact<u128>]>;149 /**150 * Transfer some liquid free balance to another account.151 * 152 * `transfer` will set the `FreeBalance` of the sender and receiver.153 * If the sender's account is below the existential deposit as a result154 * of the transfer, the account will be reaped.155 * 156 * The dispatch origin for this call must be `Signed` by the transactor.157 * 158 * # <weight>159 * - Dependent on arguments but not critical, given proper implementations for input config160 * types. See related functions below.161 * - It contains a limited number of reads and writes internally and no complex162 * computation.163 * 164 * Related functions:165 * 166 * - `ensure_can_withdraw` is always called internally but has a bounded complexity.167 * - Transferring balances to accounts that did not exist before will cause168 * `T::OnNewAccount::on_new_account` to be called.169 * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.170 * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check171 * that the transfer will not kill the origin account.172 * ---------------------------------173 * - Origin account is already in memory, so no DB operations for them.174 * # </weight>175 **/176 transfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;177 /**178 * Transfer the entire transferable balance from the caller account.179 * 180 * NOTE: This function only attempts to transfer _transferable_ balances. This means that181 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be182 * transferred by this function. To ensure that this function results in a killed account,183 * you might need to prepare the account by removing any reference counters, storage184 * deposits, etc...185 * 186 * The dispatch origin of this call must be Signed.187 * 188 * - `dest`: The recipient of the transfer.189 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all190 * of the funds the account has, causing the sender account to be killed (false), or191 * transfer everything except at least the existential deposit, which will guarantee to192 * keep the sender account alive (true). # <weight>193 * - O(1). Just like transfer, but reading the user's transferable balance first.194 * #</weight>195 **/196 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;197 /**198 * Same as the [`transfer`] call, but with a check that the transfer will not kill the199 * origin account.200 * 201 * 99% of the time you want [`transfer`] instead.202 * 203 * [`transfer`]: struct.Pallet.html#method.transfer204 **/205 transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;206 /**207 * Generic tx208 **/209 [key: string]: SubmittableExtrinsicFunction<ApiType>;210 };211 charging: {212 /**213 * Generic tx214 **/215 [key: string]: SubmittableExtrinsicFunction<ApiType>;216 };217 configuration: {218 setAppPromotionConfigurationOverride: AugmentedSubmittable<(configuration: PalletConfigurationAppPromotionConfiguration | { recalculationInterval?: any; pendingInterval?: any; intervalIncome?: any; maxStakersPerCalculation?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletConfigurationAppPromotionConfiguration]>;219 setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;220 setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;221 setXcmAllowedLocations: AugmentedSubmittable<(locations: Option<Vec<XcmV1MultiLocation>> | null | Uint8Array | Vec<XcmV1MultiLocation> | (XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<Vec<XcmV1MultiLocation>>]>;222 /**223 * Generic tx224 **/225 [key: string]: SubmittableExtrinsicFunction<ApiType>;226 };227 cumulusXcm: {228 /**229 * Generic tx230 **/231 [key: string]: SubmittableExtrinsicFunction<ApiType>;232 };233 dmpQueue: {234 /**235 * Service a single overweight message.236 * 237 * - `origin`: Must pass `ExecuteOverweightOrigin`.238 * - `index`: The index of the overweight message to service.239 * - `weight_limit`: The amount of weight that message execution may take.240 * 241 * Errors:242 * - `Unknown`: Message of `index` is unknown.243 * - `OverLimit`: Message execution may use greater than `weight_limit`.244 * 245 * Events:246 * - `OverweightServiced`: On success.247 **/248 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;249 /**250 * Generic tx251 **/252 [key: string]: SubmittableExtrinsicFunction<ApiType>;253 };254 ethereum: {255 /**256 * Transact an Ethereum transaction.257 **/258 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;259 /**260 * Generic tx261 **/262 [key: string]: SubmittableExtrinsicFunction<ApiType>;263 };264 evm: {265 /**266 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.267 **/268 call: AugmentedSubmittable<(source: H160 | string | Uint8Array, target: H160 | string | Uint8Array, input: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, H160, Bytes, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;269 /**270 * Issue an EVM create operation. This is similar to a contract creation transaction in271 * Ethereum.272 **/273 create: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, Bytes, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;274 /**275 * Issue an EVM create2 operation.276 **/277 create2: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, salt: H256 | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, Bytes, H256, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;278 /**279 * Withdraw balance from EVM into currency/balances pallet.280 **/281 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;282 /**283 * Generic tx284 **/285 [key: string]: SubmittableExtrinsicFunction<ApiType>;286 };287 evmMigration: {288 /**289 * Start contract migration, inserts contract stub at target address,290 * and marks account as pending, allowing to insert storage291 **/292 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;293 /**294 * Finish contract migration, allows it to be called.295 * It is not possible to alter contract storage via [`Self::set_data`]296 * after this call.297 **/298 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;299 /**300 * Create ethereum events attached to the fake transaction301 **/302 insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;303 /**304 * Create substrate events305 **/306 insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;307 /**308 * Insert items into contract storage, this method can be called309 * multiple times310 **/311 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;312 /**313 * Generic tx314 **/315 [key: string]: SubmittableExtrinsicFunction<ApiType>;316 };317 foreignAssets: {318 registerForeignAsset: AugmentedSubmittable<(owner: AccountId32 | string | Uint8Array, location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;319 updateForeignAsset: AugmentedSubmittable<(foreignAssetId: u32 | AnyNumber | Uint8Array, location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;320 /**321 * Generic tx322 **/323 [key: string]: SubmittableExtrinsicFunction<ApiType>;324 };325 inflation: {326 /**327 * This method sets the inflation start date. Can be only called once.328 * Inflation start block can be backdated and will catch up. The method will create Treasury329 * account if it does not exist and perform the first inflation deposit.330 * 331 * # Permissions332 * 333 * * Root334 * 335 * # Arguments336 * 337 * * inflation_start_relay_block: The relay chain block at which inflation should start338 **/339 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;340 /**341 * Generic tx342 **/343 [key: string]: SubmittableExtrinsicFunction<ApiType>;344 };345 maintenance: {346 disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;347 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;348 /**349 * Generic tx350 **/351 [key: string]: SubmittableExtrinsicFunction<ApiType>;352 };353 parachainSystem: {354 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;355 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;356 /**357 * Set the current validation data.358 * 359 * This should be invoked exactly once per block. It will panic at the finalization360 * phase if the call was not invoked.361 * 362 * The dispatch origin for this call must be `Inherent`363 * 364 * As a side effect, this function upgrades the current validation function365 * if the appropriate time has come.366 **/367 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;368 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;369 /**370 * Generic tx371 **/372 [key: string]: SubmittableExtrinsicFunction<ApiType>;373 };374 polkadotXcm: {375 /**376 * Execute an XCM message from a local, signed, origin.377 * 378 * An event is deposited indicating whether `msg` could be executed completely or only379 * partially.380 * 381 * No more than `max_weight` will be used in its attempted execution. If this is less than the382 * maximum amount of weight that the message could take to be executed, then no execution383 * attempt will be made.384 * 385 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully386 * to completion; only that *some* of it was executed.387 **/388 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;389 /**390 * Set a safe XCM version (the version that XCM should be encoded with if the most recent391 * version a destination can accept is unknown).392 * 393 * - `origin`: Must be Root.394 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.395 **/396 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;397 /**398 * Ask a location to notify us regarding their XCM version and any changes to it.399 * 400 * - `origin`: Must be Root.401 * - `location`: The location to which we should subscribe for XCM version notifications.402 **/403 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;404 /**405 * Require that a particular destination should no longer notify us regarding any XCM406 * version changes.407 * 408 * - `origin`: Must be Root.409 * - `location`: The location to which we are currently subscribed for XCM version410 * notifications which we no longer desire.411 **/412 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;413 /**414 * Extoll that a particular destination can be communicated with through a particular415 * version of XCM.416 * 417 * - `origin`: Must be Root.418 * - `location`: The destination that is being described.419 * - `xcm_version`: The latest version of XCM that `location` supports.420 **/421 forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;422 /**423 * Transfer some assets from the local chain to the sovereign account of a destination424 * chain and forward a notification XCM.425 * 426 * Fee payment on the destination side is made from the asset in the `assets` vector of427 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight428 * is needed than `weight_limit`, then the operation will fail and the assets send may be429 * at risk.430 * 431 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.432 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send433 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.434 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be435 * an `AccountId32` value.436 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the437 * `dest` side.438 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay439 * fees.440 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.441 **/442 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]>;443 /**444 * Teleport some assets from the local chain to some destination chain.445 * 446 * Fee payment on the destination side is made from the asset in the `assets` vector of447 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight448 * is needed than `weight_limit`, then the operation will fail and the assets send may be449 * at risk.450 * 451 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.452 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send453 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.454 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be455 * an `AccountId32` value.456 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the457 * `dest` side. May not be empty.458 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay459 * fees.460 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.461 **/462 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]>;463 /**464 * Transfer some assets from the local chain to the sovereign account of a destination465 * chain and forward a notification XCM.466 * 467 * Fee payment on the destination side is made from the asset in the `assets` vector of468 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,469 * with all fees taken as needed from the asset.470 * 471 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.472 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send473 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.474 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be475 * an `AccountId32` value.476 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the477 * `dest` side.478 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay479 * fees.480 **/481 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]>;482 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;483 /**484 * Teleport some assets from the local chain to some destination chain.485 * 486 * Fee payment on the destination side is made from the asset in the `assets` vector of487 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,488 * with all fees taken as needed from the asset.489 * 490 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.491 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send492 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.493 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be494 * an `AccountId32` value.495 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the496 * `dest` side. May not be empty.497 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay498 * fees.499 **/500 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]>;501 /**502 * Generic tx503 **/504 [key: string]: SubmittableExtrinsicFunction<ApiType>;505 };506 rmrkCore: {507 /**508 * Accept an NFT sent from another account to self or an owned NFT.509 * 510 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.511 * 512 * # Permissions:513 * - Token-owner-to-be514 * 515 * # Arguments:516 * - `origin`: sender of the transaction517 * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.518 * - `rmrk_nft_id`: ID of the NFT to be accepted.519 * - `new_owner`: Either the sender's account ID or a sender-owned NFT,520 * whichever the accepted NFT was sent to.521 **/522 acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;523 /**524 * Accept the addition of a newly created pending resource to an existing NFT.525 * 526 * This transaction is needed when a resource is created and assigned to an NFT527 * by a non-owner, i.e. the collection issuer, with one of the528 * [`add_...` transactions](Pallet::add_basic_resource).529 * 530 * # Permissions:531 * - Token owner532 * 533 * # Arguments:534 * - `origin`: sender of the transaction535 * - `rmrk_collection_id`: RMRK collection ID of the NFT.536 * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.537 * - `resource_id`: ID of the newly created pending resource.538 * accept the addition of a new resource to an existing NFT539 **/540 acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;541 /**542 * Accept the removal of a removal-pending resource from an NFT.543 * 544 * This transaction is needed when a non-owner, i.e. the collection issuer,545 * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.546 * 547 * # Permissions:548 * - Token owner549 * 550 * # Arguments:551 * - `origin`: sender of the transaction552 * - `rmrk_collection_id`: RMRK collection ID of the NFT.553 * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.554 * - `resource_id`: ID of the removal-pending resource.555 **/556 acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;557 /**558 * Create and set/propose a basic resource for an NFT.559 * 560 * A basic resource is the simplest, lacking a Base and anything that comes with it.561 * See RMRK docs for more information and examples.562 * 563 * # Permissions:564 * - Collection issuer - if not the token owner, adding the resource will warrant565 * the owner's [acceptance](Pallet::accept_resource).566 * 567 * # Arguments:568 * - `origin`: sender of the transaction569 * - `rmrk_collection_id`: RMRK collection ID of the NFT.570 * - `nft_id`: ID of the NFT to assign a resource to.571 * - `resource`: Data of the resource to be created.572 **/573 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]>;574 /**575 * Create and set/propose a composable resource for an NFT.576 * 577 * A composable resource links to a Base and has a subset of its Parts it is composed of.578 * See RMRK docs for more information and examples.579 * 580 * # Permissions:581 * - Collection issuer - if not the token owner, adding the resource will warrant582 * the owner's [acceptance](Pallet::accept_resource).583 * 584 * # Arguments:585 * - `origin`: sender of the transaction586 * - `rmrk_collection_id`: RMRK collection ID of the NFT.587 * - `nft_id`: ID of the NFT to assign a resource to.588 * - `resource`: Data of the resource to be created.589 **/590 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]>;591 /**592 * Create and set/propose a slot resource for an NFT.593 * 594 * A slot resource links to a Base and a slot ID in it which it can fit into.595 * See RMRK docs for more information and examples.596 * 597 * # Permissions:598 * - Collection issuer - if not the token owner, adding the resource will warrant599 * the owner's [acceptance](Pallet::accept_resource).600 * 601 * # Arguments:602 * - `origin`: sender of the transaction603 * - `rmrk_collection_id`: RMRK collection ID of the NFT.604 * - `nft_id`: ID of the NFT to assign a resource to.605 * - `resource`: Data of the resource to be created.606 **/607 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]>;608 /**609 * Burn an NFT, destroying it and its nested tokens up to the specified limit.610 * If the burning budget is exceeded, the transaction is reverted.611 * 612 * This is the way to burn a nested token as well.613 * 614 * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).615 * 616 * # Permissions:617 * * Token owner618 * 619 * # Arguments:620 * - `origin`: sender of the transaction621 * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.622 * - `nft_id`: ID of the NFT to be destroyed.623 * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction624 * is reverted if there are more tokens to burn in the nesting tree than this number.625 * This is primarily a mechanism of transaction weight control.626 **/627 burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;628 /**629 * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).630 * 631 * # Permissions:632 * * Collection issuer633 * 634 * # Arguments:635 * - `origin`: sender of the transaction636 * - `collection_id`: RMRK collection ID to change the issuer of.637 * - `new_issuer`: Collection's new issuer.638 **/639 changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;640 /**641 * Create a new collection of NFTs.642 * 643 * # Permissions:644 * * Anyone - will be assigned as the issuer of the collection.645 * 646 * # Arguments:647 * - `origin`: sender of the transaction648 * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.649 * - `max`: Optional maximum number of tokens.650 * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.651 * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.652 **/653 createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;654 /**655 * Destroy a collection.656 * 657 * Only empty collections can be destroyed. If it has any tokens, they must be burned first.658 * 659 * # Permissions:660 * * Collection issuer661 * 662 * # Arguments:663 * - `origin`: sender of the transaction664 * - `collection_id`: RMRK ID of the collection to destroy.665 **/666 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;667 /**668 * "Lock" the collection and prevent new token creation. Cannot be undone.669 * 670 * # Permissions:671 * * Collection issuer672 * 673 * # Arguments:674 * - `origin`: sender of the transaction675 * - `collection_id`: RMRK ID of the collection to lock.676 **/677 lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;678 /**679 * Mint an NFT in a specified collection.680 * 681 * # Permissions:682 * * Collection issuer683 * 684 * # Arguments:685 * - `origin`: sender of the transaction686 * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).687 * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.688 * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.689 * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.690 * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.691 * - `transferable`: Can this NFT be transferred? Cannot be changed.692 * - `resources`: Resource data to be added to the NFT immediately after minting.693 **/694 mintNft: AugmentedSubmittable<(owner: Option<AccountId32> | null | Uint8Array | AccountId32 | string, collectionId: u32 | AnyNumber | Uint8Array, recipient: Option<AccountId32> | null | Uint8Array | AccountId32 | string, royaltyAmount: Option<Permill> | null | Uint8Array | Permill | AnyNumber, metadata: Bytes | string | Uint8Array, transferable: bool | boolean | Uint8Array, resources: Option<Vec<RmrkTraitsResourceResourceTypes>> | null | Uint8Array | Vec<RmrkTraitsResourceResourceTypes> | (RmrkTraitsResourceResourceTypes | { Basic: any } | { Composable: any } | { Slot: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<AccountId32>, u32, Option<AccountId32>, Option<Permill>, Bytes, bool, Option<Vec<RmrkTraitsResourceResourceTypes>>]>;695 /**696 * Reject an NFT sent from another account to self or owned NFT.697 * The NFT in question will not be sent back and burnt instead.698 * 699 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.700 * 701 * # Permissions:702 * - Token-owner-to-be-not703 * 704 * # Arguments:705 * - `origin`: sender of the transaction706 * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.707 * - `rmrk_nft_id`: ID of the NFT to be rejected.708 **/709 rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;710 /**711 * Remove and erase a resource from an NFT.712 * 713 * If the sender does not own the NFT, then it will be pending confirmation,714 * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.715 * 716 * # Permissions717 * - Collection issuer718 * 719 * # Arguments720 * - `origin`: sender of the transaction721 * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.722 * - `nft_id`: ID of the NFT with a resource to be removed.723 * - `resource_id`: ID of the resource to be removed.724 **/725 removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;726 /**727 * Transfer an NFT from an account/NFT A to another account/NFT B.728 * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].729 * 730 * If the target owner is an NFT owned by another account, then the NFT will enter731 * the pending state and will have to be accepted by the other account.732 * 733 * # Permissions:734 * - Token owner735 * 736 * # Arguments:737 * - `origin`: sender of the transaction738 * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.739 * - `rmrk_nft_id`: ID of the NFT to be transferred.740 * - `new_owner`: New owner of the nft which can be either an account or a NFT.741 **/742 send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;743 /**744 * Set a different order of resource priorities for an NFT. Priorities can be used,745 * for example, for order of rendering.746 * 747 * Note that the priorities are not updated automatically, and are an empty vector748 * by default. There is no pre-set definition for the order to be particular,749 * it can be interpreted arbitrarily use-case by use-case.750 * 751 * # Permissions:752 * - Token owner753 * 754 * # Arguments:755 * - `origin`: sender of the transaction756 * - `rmrk_collection_id`: RMRK collection ID of the NFT.757 * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.758 * - `priorities`: Ordered vector of resource IDs.759 **/760 setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;761 /**762 * Add or edit a custom user property, a key-value pair, describing the metadata763 * of a token or a collection, on either one of these.764 * 765 * Note that in this proxy implementation many details regarding RMRK are stored766 * as scoped properties prefixed with "rmrk:", normally inaccessible767 * to external transactions and RPCs.768 * 769 * # Permissions:770 * - Collection issuer - in case of collection property771 * - Token owner - in case of NFT property772 * 773 * # Arguments:774 * - `origin`: sender of the transaction775 * - `rmrk_collection_id`: RMRK collection ID.776 * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.777 * - `key`: Key of the custom property to be referenced by.778 * - `value`: Value of the custom property to be stored.779 **/780 setProperty: AugmentedSubmittable<(rmrkCollectionId: Compact<u32> | AnyNumber | Uint8Array, maybeNftId: Option<u32> | null | Uint8Array | u32 | AnyNumber, key: Bytes | string | Uint8Array, value: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Option<u32>, Bytes, Bytes]>;781 /**782 * Generic tx783 **/784 [key: string]: SubmittableExtrinsicFunction<ApiType>;785 };786 rmrkEquip: {787 /**788 * Create a new Base.789 * 790 * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)791 * 792 * # Permissions793 * - Anyone - will be assigned as the issuer of the Base.794 * 795 * # Arguments:796 * - `origin`: Caller, will be assigned as the issuer of the Base797 * - `base_type`: Arbitrary media type, e.g. "svg".798 * - `symbol`: Arbitrary client-chosen symbol.799 * - `parts`: Array of Fixed and Slot Parts composing the Base,800 * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).801 **/802 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>]>;803 /**804 * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.805 * 806 * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).807 * 808 * # Permissions:809 * - Base issuer810 * 811 * # Arguments:812 * - `origin`: sender of the transaction813 * - `base_id`: Base containing the Slot Part to be updated.814 * - `slot_id`: Slot Part whose Equippable List is being updated .815 * - `equippables`: List of equippables that will override the current Equippables list.816 **/817 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]>;818 /**819 * Add a Theme to a Base.820 * A Theme named "default" is required prior to adding other Themes.821 * 822 * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).823 * 824 * # Permissions:825 * - Base issuer826 * 827 * # Arguments:828 * - `origin`: sender of the transaction829 * - `base_id`: Base ID containing the Theme to be updated.830 * - `theme`: Theme to add to the Base. A Theme has a name and properties, which are an831 * array of [key, value, inherit].832 * - `key`: Arbitrary BoundedString, defined by client.833 * - `value`: Arbitrary BoundedString, defined by client.834 * - `inherit`: Optional bool.835 **/836 themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;837 /**838 * Generic tx839 **/840 [key: string]: SubmittableExtrinsicFunction<ApiType>;841 };842 structure: {843 /**844 * Generic tx845 **/846 [key: string]: SubmittableExtrinsicFunction<ApiType>;847 };848 sudo: {849 /**850 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo851 * key.852 * 853 * The dispatch origin for this call must be _Signed_.854 * 855 * # <weight>856 * - O(1).857 * - Limited storage reads.858 * - One DB change.859 * # </weight>860 **/861 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;862 /**863 * Authenticates the sudo key and dispatches a function call with `Root` origin.864 * 865 * The dispatch origin for this call must be _Signed_.866 * 867 * # <weight>868 * - O(1).869 * - Limited storage reads.870 * - One DB write (event).871 * - Weight of derivative `call` execution + 10,000.872 * # </weight>873 **/874 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;875 /**876 * Authenticates the sudo key and dispatches a function call with `Signed` origin from877 * a given account.878 * 879 * The dispatch origin for this call must be _Signed_.880 * 881 * # <weight>882 * - O(1).883 * - Limited storage reads.884 * - One DB write (event).885 * - Weight of derivative `call` execution + 10,000.886 * # </weight>887 **/888 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]>;889 /**890 * Authenticates the sudo key and dispatches a function call with `Root` origin.891 * This function does not check the weight of the call, and instead allows the892 * Sudo user to specify the weight of the call.893 * 894 * The dispatch origin for this call must be _Signed_.895 * 896 * # <weight>897 * - O(1).898 * - The weight of this call is defined by the caller.899 * # </weight>900 **/901 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;902 /**903 * Generic tx904 **/905 [key: string]: SubmittableExtrinsicFunction<ApiType>;906 };907 system: {908 /**909 * A dispatch that will fill the block weight up to the given ratio.910 **/911 fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;912 /**913 * Kill all storage items with a key that starts with the given prefix.914 * 915 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under916 * the prefix we are removing to accurately calculate the weight of this function.917 **/918 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;919 /**920 * Kill some items from storage.921 **/922 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;923 /**924 * Make some on-chain remark.925 * 926 * # <weight>927 * - `O(1)`928 * # </weight>929 **/930 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;931 /**932 * Make some on-chain remark and emit event.933 **/934 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;935 /**936 * Set the new runtime code.937 * 938 * # <weight>939 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`940 * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is941 * expensive).942 * - 1 storage write (codec `O(C)`).943 * - 1 digest item.944 * - 1 event.945 * The weight of this function is dependent on the runtime, but generally this is very946 * expensive. We will treat this as a full block.947 * # </weight>948 **/949 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;950 /**951 * Set the new runtime code without doing any checks of the given `code`.952 * 953 * # <weight>954 * - `O(C)` where `C` length of `code`955 * - 1 storage write (codec `O(C)`).956 * - 1 digest item.957 * - 1 event.958 * The weight of this function is dependent on the runtime. We will treat this as a full959 * block. # </weight>960 **/961 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;962 /**963 * Set the number of pages in the WebAssembly environment's heap.964 **/965 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;966 /**967 * Set some items of storage.968 **/969 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;970 /**971 * Generic tx972 **/973 [key: string]: SubmittableExtrinsicFunction<ApiType>;974 };975 testUtils: {976 batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;977 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;978 incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;979 justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;980 setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;981 setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;982 /**983 * Generic tx984 **/985 [key: string]: SubmittableExtrinsicFunction<ApiType>;986 };987 timestamp: {988 /**989 * Set the current time.990 * 991 * This call should be invoked exactly once per block. It will panic at the finalization992 * phase, if this call hasn't been invoked by that time.993 * 994 * The timestamp should be greater than the previous one by the amount specified by995 * `MinimumPeriod`.996 * 997 * The dispatch origin for this call must be `Inherent`.998 * 999 * # <weight>1000 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1001 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1002 * `on_finalize`)1003 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1004 * # </weight>1005 **/1006 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1007 /**1008 * Generic tx1009 **/1010 [key: string]: SubmittableExtrinsicFunction<ApiType>;1011 };1012 tokens: {1013 /**1014 * Exactly as `transfer`, except the origin must be root and the source1015 * account may be specified.1016 * 1017 * The dispatch origin for this call must be _Root_.1018 * 1019 * - `source`: The sender of the transfer.1020 * - `dest`: The recipient of the transfer.1021 * - `currency_id`: currency type.1022 * - `amount`: free balance amount to tranfer.1023 **/1024 forceTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, PalletForeignAssetsAssetIds, Compact<u128>]>;1025 /**1026 * Set the balances of a given account.1027 * 1028 * This will alter `FreeBalance` and `ReservedBalance` in storage. it1029 * will also decrease the total issuance of the system1030 * (`TotalIssuance`). If the new free or reserved balance is below the1031 * existential deposit, it will reap the `AccountInfo`.1032 * 1033 * The dispatch origin for this call is `root`.1034 **/1035 setBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, newReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeignAssetsAssetIds, Compact<u128>, Compact<u128>]>;1036 /**1037 * Transfer some liquid free balance to another account.1038 * 1039 * `transfer` will set the `FreeBalance` of the sender and receiver.1040 * It will decrease the total issuance of the system by the1041 * `TransferFee`. If the sender's account is below the existential1042 * deposit as a result of the transfer, the account will be reaped.1043 * 1044 * The dispatch origin for this call must be `Signed` by the1045 * transactor.1046 * 1047 * - `dest`: The recipient of the transfer.1048 * - `currency_id`: currency type.1049 * - `amount`: free balance amount to tranfer.1050 **/1051 transfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeignAssetsAssetIds, Compact<u128>]>;1052 /**1053 * Transfer all remaining balance to the given account.1054 * 1055 * NOTE: This function only attempts to transfer _transferable_1056 * balances. This means that any locked, reserved, or existential1057 * deposits (when `keep_alive` is `true`), will not be transferred by1058 * this function. To ensure that this function results in a killed1059 * account, you might need to prepare the account by removing any1060 * reference counters, storage deposits, etc...1061 * 1062 * The dispatch origin for this call must be `Signed` by the1063 * transactor.1064 * 1065 * - `dest`: The recipient of the transfer.1066 * - `currency_id`: currency type.1067 * - `keep_alive`: A boolean to determine if the `transfer_all`1068 * operation should send all of the funds the account has, causing1069 * the sender account to be killed (false), or transfer everything1070 * except at least the existential deposit, which will guarantee to1071 * keep the sender account alive (true).1072 **/1073 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeignAssetsAssetIds, bool]>;1074 /**1075 * Same as the [`transfer`] call, but with a check that the transfer1076 * will not kill the origin account.1077 * 1078 * 99% of the time you want [`transfer`] instead.1079 * 1080 * The dispatch origin for this call must be `Signed` by the1081 * transactor.1082 * 1083 * - `dest`: The recipient of the transfer.1084 * - `currency_id`: currency type.1085 * - `amount`: free balance amount to tranfer.1086 **/1087 transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeignAssetsAssetIds, Compact<u128>]>;1088 /**1089 * Generic tx1090 **/1091 [key: string]: SubmittableExtrinsicFunction<ApiType>;1092 };1093 treasury: {1094 /**1095 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1096 * and the original deposit will be returned.1097 * 1098 * May only be called from `T::ApproveOrigin`.1099 * 1100 * # <weight>1101 * - Complexity: O(1).1102 * - DbReads: `Proposals`, `Approvals`1103 * - DbWrite: `Approvals`1104 * # </weight>1105 **/1106 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1107 /**1108 * Put forward a suggestion for spending. A deposit proportional to the value1109 * is reserved and slashed if the proposal is rejected. It is returned once the1110 * proposal is awarded.1111 * 1112 * # <weight>1113 * - Complexity: O(1)1114 * - DbReads: `ProposalCount`, `origin account`1115 * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1116 * # </weight>1117 **/1118 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]>;1119 /**1120 * Reject a proposed spend. The original deposit will be slashed.1121 * 1122 * May only be called from `T::RejectOrigin`.1123 * 1124 * # <weight>1125 * - Complexity: O(1)1126 * - DbReads: `Proposals`, `rejected proposer account`1127 * - DbWrites: `Proposals`, `rejected proposer account`1128 * # </weight>1129 **/1130 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1131 /**1132 * Force a previously approved proposal to be removed from the approval queue.1133 * The original deposit will no longer be returned.1134 * 1135 * May only be called from `T::RejectOrigin`.1136 * - `proposal_id`: The index of a proposal1137 * 1138 * # <weight>1139 * - Complexity: O(A) where `A` is the number of approvals1140 * - Db reads and writes: `Approvals`1141 * # </weight>1142 * 1143 * Errors:1144 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1145 * i.e., the proposal has not been approved. This could also mean the proposal does not1146 * exist altogether, thus there is no way it would have been approved in the first place.1147 **/1148 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1149 /**1150 * Propose and approve a spend of treasury funds.1151 * 1152 * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1153 * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1154 * - `beneficiary`: The destination account for the transfer.1155 * 1156 * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1157 * beneficiary.1158 **/1159 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]>;1160 /**1161 * Generic tx1162 **/1163 [key: string]: SubmittableExtrinsicFunction<ApiType>;1164 };1165 unique: {1166 /**1167 * Add an admin to a collection.1168 * 1169 * NFT Collection can be controlled by multiple admin addresses1170 * (some which can also be servers, for example). Admins can issue1171 * and burn NFTs, as well as add and remove other admins,1172 * but cannot change NFT or Collection ownership.1173 * 1174 * # Permissions1175 * 1176 * * Collection owner1177 * * Collection admin1178 * 1179 * # Arguments1180 * 1181 * * `collection_id`: ID of the Collection to add an admin for.1182 * * `new_admin`: Address of new admin to add.1183 **/1184 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1185 /**1186 * Add an address to allow list.1187 * 1188 * # Permissions1189 * 1190 * * Collection owner1191 * * Collection admin1192 * 1193 * # Arguments1194 * 1195 * * `collection_id`: ID of the modified collection.1196 * * `address`: ID of the address to be added to the allowlist.1197 **/1198 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1199 /**1200 * Allow a non-permissioned address to transfer or burn an item.1201 * 1202 * # Permissions1203 * 1204 * * Collection owner1205 * * Collection admin1206 * * Current item owner1207 * 1208 * # Arguments1209 * 1210 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1211 * * `collection_id`: ID of the collection the item belongs to.1212 * * `item_id`: ID of the item transactions on which are now approved.1213 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1214 * Set to 0 to revoke the approval.1215 **/1216 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]>;1217 /**1218 * Destroy a token on behalf of the owner as a non-owner account.1219 * 1220 * See also: [`approve`][`Pallet::approve`].1221 * 1222 * After this method executes, one approval is removed from the total so that1223 * the approved address will not be able to transfer this item again from this owner.1224 * 1225 * # Permissions1226 * 1227 * * Collection owner1228 * * Collection admin1229 * * Current token owner1230 * * Address approved by current item owner1231 * 1232 * # Arguments1233 * 1234 * * `from`: The owner of the burning item.1235 * * `collection_id`: ID of the collection to which the item belongs.1236 * * `item_id`: ID of item to burn.1237 * * `value`: Number of pieces to burn.1238 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1239 * * Fungible Mode: The desired number of pieces to burn.1240 * * Re-Fungible Mode: The desired number of pieces to burn.1241 **/1242 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]>;1243 /**1244 * Destroy an item.1245 * 1246 * # Permissions1247 * 1248 * * Collection owner1249 * * Collection admin1250 * * Current item owner1251 * 1252 * # Arguments1253 * 1254 * * `collection_id`: ID of the collection to which the item belongs.1255 * * `item_id`: ID of item to burn.1256 * * `value`: Number of pieces of the item to destroy.1257 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1258 * * Fungible Mode: The desired number of pieces to burn.1259 * * Re-Fungible Mode: The desired number of pieces to burn.1260 **/1261 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1262 /**1263 * Change the owner of the collection.1264 * 1265 * # Permissions1266 * 1267 * * Collection owner1268 * 1269 * # Arguments1270 * 1271 * * `collection_id`: ID of the modified collection.1272 * * `new_owner`: ID of the account that will become the owner.1273 **/1274 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1275 /**1276 * Confirm own sponsorship of a collection, becoming the sponsor.1277 * 1278 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1279 * Sponsor can pay the fees of a transaction instead of the sender,1280 * but only within specified limits.1281 * 1282 * # Permissions1283 * 1284 * * Sponsor-to-be1285 * 1286 * # Arguments1287 * 1288 * * `collection_id`: ID of the collection with the pending sponsor.1289 **/1290 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1291 /**1292 * Create a collection of tokens.1293 * 1294 * Each Token may have multiple properties encoded as an array of bytes1295 * of certain length. The initial owner of the collection is set1296 * to the address that signed the transaction and can be changed later.1297 * 1298 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1299 * 1300 * # Permissions1301 * 1302 * * Anyone - becomes the owner of the new collection.1303 * 1304 * # Arguments1305 * 1306 * * `collection_name`: Wide-character string with collection name1307 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1308 * * `collection_description`: Wide-character string with collection description1309 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1310 * * `token_prefix`: Byte string containing the token prefix to mark a collection1311 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1312 * * `mode`: Type of items stored in the collection and type dependent data.1313 **/1314 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]>;1315 /**1316 * Create a collection with explicit parameters.1317 * 1318 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1319 * 1320 * # Permissions1321 * 1322 * * Anyone - becomes the owner of the new collection.1323 * 1324 * # Arguments1325 * 1326 * * `data`: Explicit data of a collection used for its creation.1327 **/1328 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]>;1329 /**1330 * Mint an item within a collection.1331 * 1332 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1333 * 1334 * # Permissions1335 * 1336 * * Collection owner1337 * * Collection admin1338 * * Anyone if1339 * * Allow List is enabled, and1340 * * Address is added to allow list, and1341 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1342 * 1343 * # Arguments1344 * 1345 * * `collection_id`: ID of the collection to which an item would belong.1346 * * `owner`: Address of the initial owner of the item.1347 * * `data`: Token data describing the item to store on chain.1348 **/1349 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]>;1350 /**1351 * Create multiple items within a collection.1352 * 1353 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1354 * 1355 * # Permissions1356 * 1357 * * Collection owner1358 * * Collection admin1359 * * Anyone if1360 * * Allow List is enabled, and1361 * * Address is added to the allow list, and1362 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1363 * 1364 * # Arguments1365 * 1366 * * `collection_id`: ID of the collection to which the tokens would belong.1367 * * `owner`: Address of the initial owner of the tokens.1368 * * `items_data`: Vector of data describing each item to be created.1369 **/1370 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>]>;1371 /**1372 * Create multiple items within a collection with explicitly specified initial parameters.1373 * 1374 * # Permissions1375 * 1376 * * Collection owner1377 * * Collection admin1378 * * Anyone if1379 * * Allow List is enabled, and1380 * * Address is added to allow list, and1381 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1382 * 1383 * # Arguments1384 * 1385 * * `collection_id`: ID of the collection to which the tokens would belong.1386 * * `data`: Explicit item creation data.1387 **/1388 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1389 /**1390 * Delete specified collection properties.1391 * 1392 * # Permissions1393 * 1394 * * Collection Owner1395 * * Collection Admin1396 * 1397 * # Arguments1398 * 1399 * * `collection_id`: ID of the modified collection.1400 * * `property_keys`: Vector of keys of the properties to be deleted.1401 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1402 **/1403 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1404 /**1405 * Delete specified token properties. Currently properties only work with NFTs.1406 * 1407 * # Permissions1408 * 1409 * * Depends on collection's token property permissions and specified property mutability:1410 * * Collection owner1411 * * Collection admin1412 * * Token owner1413 * 1414 * # Arguments1415 * 1416 * * `collection_id`: ID of the collection to which the token belongs.1417 * * `token_id`: ID of the modified token.1418 * * `property_keys`: Vector of keys of the properties to be deleted.1419 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1420 **/1421 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1422 /**1423 * Destroy a collection if no tokens exist within.1424 * 1425 * # Permissions1426 * 1427 * * Collection owner1428 * 1429 * # Arguments1430 * 1431 * * `collection_id`: Collection to destroy.1432 **/1433 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1434 /**1435 * Remove admin of a collection.1436 * 1437 * An admin address can remove itself. List of admins may become empty,1438 * in which case only Collection Owner will be able to add an Admin.1439 * 1440 * # Permissions1441 * 1442 * * Collection owner1443 * * Collection admin1444 * 1445 * # Arguments1446 * 1447 * * `collection_id`: ID of the collection to remove the admin for.1448 * * `account_id`: Address of the admin to remove.1449 **/1450 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1451 /**1452 * Remove a collection's a sponsor, making everyone pay for their own transactions.1453 * 1454 * # Permissions1455 * 1456 * * Collection owner1457 * 1458 * # Arguments1459 * 1460 * * `collection_id`: ID of the collection with the sponsor to remove.1461 **/1462 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1463 /**1464 * Remove an address from allow list.1465 * 1466 * # Permissions1467 * 1468 * * Collection owner1469 * * Collection admin1470 * 1471 * # Arguments1472 * 1473 * * `collection_id`: ID of the modified collection.1474 * * `address`: ID of the address to be removed from the allowlist.1475 **/1476 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1477 /**1478 * Repairs a broken item1479 * 1480 * # Arguments1481 * 1482 * * `collection_id`: ID of the collection the item belongs to.1483 * * `item_id`: ID of the item.1484 **/1485 repairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1486 /**1487 * Re-partition a refungible token, while owning all of its parts/pieces.1488 * 1489 * # Permissions1490 * 1491 * * Token owner (must own every part)1492 * 1493 * # Arguments1494 * 1495 * * `collection_id`: ID of the collection the RFT belongs to.1496 * * `token_id`: ID of the RFT.1497 * * `amount`: New number of parts/pieces into which the token shall be partitioned.1498 **/1499 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1500 /**1501 * Sets or unsets the approval of a given operator.1502 * 1503 * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1504 * 1505 * # Arguments1506 * 1507 * * `owner`: Token owner1508 * * `operator`: Operator1509 * * `approve`: Should operator status be granted or revoked?1510 **/1511 setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1512 /**1513 * Set specific limits of a collection. Empty, or None fields mean chain default.1514 * 1515 * # Permissions1516 * 1517 * * Collection owner1518 * * Collection admin1519 * 1520 * # Arguments1521 * 1522 * * `collection_id`: ID of the modified collection.1523 * * `new_limit`: New limits of the collection. Fields that are not set (None)1524 * will not overwrite the old ones.1525 **/1526 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]>;1527 /**1528 * Set specific permissions of a collection. Empty, or None fields mean chain default.1529 * 1530 * # Permissions1531 * 1532 * * Collection owner1533 * * Collection admin1534 * 1535 * # Arguments1536 * 1537 * * `collection_id`: ID of the modified collection.1538 * * `new_permission`: New permissions of the collection. Fields that are not set (None)1539 * will not overwrite the old ones.1540 **/1541 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1542 /**1543 * Add or change collection properties.1544 * 1545 * # Permissions1546 * 1547 * * Collection owner1548 * * Collection admin1549 * 1550 * # Arguments1551 * 1552 * * `collection_id`: ID of the modified collection.1553 * * `properties`: Vector of key-value pairs stored as the collection's metadata.1554 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1555 **/1556 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1557 /**1558 * Set (invite) a new collection sponsor.1559 * 1560 * If successful, confirmation from the sponsor-to-be will be pending.1561 * 1562 * # Permissions1563 * 1564 * * Collection owner1565 * * Collection admin1566 * 1567 * # Arguments1568 * 1569 * * `collection_id`: ID of the modified collection.1570 * * `new_sponsor`: ID of the account of the sponsor-to-be.1571 **/1572 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1573 /**1574 * Add or change token properties according to collection's permissions.1575 * Currently properties only work with NFTs.1576 * 1577 * # Permissions1578 * 1579 * * Depends on collection's token property permissions and specified property mutability:1580 * * Collection owner1581 * * Collection admin1582 * * Token owner1583 * 1584 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1585 * 1586 * # Arguments1587 * 1588 * * `collection_id: ID of the collection to which the token belongs.1589 * * `token_id`: ID of the modified token.1590 * * `properties`: Vector of key-value pairs stored as the token's metadata.1591 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1592 **/1593 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>]>;1594 /**1595 * Add or change token property permissions of a collection.1596 * 1597 * Without a permission for a particular key, a property with that key1598 * cannot be created in a token.1599 * 1600 * # Permissions1601 * 1602 * * Collection owner1603 * * Collection admin1604 * 1605 * # Arguments1606 * 1607 * * `collection_id`: ID of the modified collection.1608 * * `property_permissions`: Vector of permissions for property keys.1609 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1610 **/1611 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1612 /**1613 * Completely allow or disallow transfers for a particular collection.1614 * 1615 * # Permissions1616 * 1617 * * Collection owner1618 * 1619 * # Arguments1620 * 1621 * * `collection_id`: ID of the collection.1622 * * `value`: New value of the flag, are transfers allowed?1623 **/1624 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1625 /**1626 * Change ownership of the token.1627 * 1628 * # Permissions1629 * 1630 * * Collection owner1631 * * Collection admin1632 * * Current token owner1633 * 1634 * # Arguments1635 * 1636 * * `recipient`: Address of token recipient.1637 * * `collection_id`: ID of the collection the item belongs to.1638 * * `item_id`: ID of the item.1639 * * Non-Fungible Mode: Required.1640 * * Fungible Mode: Ignored.1641 * * Re-Fungible Mode: Required.1642 * 1643 * * `value`: Amount to transfer.1644 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1645 * * Fungible Mode: The desired number of pieces to transfer.1646 * * Re-Fungible Mode: The desired number of pieces to transfer.1647 **/1648 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]>;1649 /**1650 * Change ownership of an item on behalf of the owner as a non-owner account.1651 * 1652 * See the [`approve`][`Pallet::approve`] method for additional information.1653 * 1654 * After this method executes, one approval is removed from the total so that1655 * the approved address will not be able to transfer this item again from this owner.1656 * 1657 * # Permissions1658 * 1659 * * Collection owner1660 * * Collection admin1661 * * Current item owner1662 * * Address approved by current item owner1663 * 1664 * # Arguments1665 * 1666 * * `from`: Address that currently owns the token.1667 * * `recipient`: Address of the new token-owner-to-be.1668 * * `collection_id`: ID of the collection the item.1669 * * `item_id`: ID of the item to be transferred.1670 * * `value`: Amount to transfer.1671 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1672 * * Fungible Mode: The desired number of pieces to transfer.1673 * * Re-Fungible Mode: The desired number of pieces to transfer.1674 **/1675 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]>;1676 /**1677 * Generic tx1678 **/1679 [key: string]: SubmittableExtrinsicFunction<ApiType>;1680 };1681 vesting: {1682 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1683 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1684 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>]>;1685 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]>;1686 /**1687 * Generic tx1688 **/1689 [key: string]: SubmittableExtrinsicFunction<ApiType>;1690 };1691 xcmpQueue: {1692 /**1693 * Resumes all XCM executions for the XCMP queue.1694 * 1695 * Note that this function doesn't change the status of the in/out bound channels.1696 * 1697 * - `origin`: Must pass `ControllerOrigin`.1698 **/1699 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1700 /**1701 * Services a single overweight XCM.1702 * 1703 * - `origin`: Must pass `ExecuteOverweightOrigin`.1704 * - `index`: The index of the overweight XCM to service1705 * - `weight_limit`: The amount of weight that XCM execution may take.1706 * 1707 * Errors:1708 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1709 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1710 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1711 * 1712 * Events:1713 * - `OverweightServiced`: On success.1714 **/1715 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1716 /**1717 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1718 * 1719 * - `origin`: Must pass `ControllerOrigin`.1720 **/1721 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1722 /**1723 * Overwrites the number of pages of messages which must be in the queue after which we drop any further1724 * messages from the channel.1725 * 1726 * - `origin`: Must pass `Root`.1727 * - `new`: Desired value for `QueueConfigData.drop_threshold`1728 **/1729 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1730 /**1731 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1732 * message sending may recommence after it has been suspended.1733 * 1734 * - `origin`: Must pass `Root`.1735 * - `new`: Desired value for `QueueConfigData.resume_threshold`1736 **/1737 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1738 /**1739 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1740 * suspend their sending.1741 * 1742 * - `origin`: Must pass `Root`.1743 * - `new`: Desired value for `QueueConfigData.suspend_value`1744 **/1745 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1746 /**1747 * Overwrites the amount of remaining weight under which we stop processing messages.1748 * 1749 * - `origin`: Must pass `Root`.1750 * - `new`: Desired value for `QueueConfigData.threshold_weight`1751 **/1752 updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1753 /**1754 * Overwrites the speed to which the available weight approaches the maximum weight.1755 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1756 * 1757 * - `origin`: Must pass `Root`.1758 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1759 **/1760 updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1761 /**1762 * Overwrite the maximum amount of weight any individual message may consume.1763 * Messages above this weight go into the overweight queue and may only be serviced explicitly.1764 * 1765 * - `origin`: Must pass `Root`.1766 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1767 **/1768 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1769 /**1770 * Generic tx1771 **/1772 [key: string]: SubmittableExtrinsicFunction<ApiType>;1773 };1774 xTokens: {1775 /**1776 * Transfer native currencies.1777 * 1778 * `dest_weight_limit` is the weight for XCM execution on the dest1779 * chain, and it would be charged from the transferred assets. If set1780 * below requirements, the execution may fail and assets wouldn't be1781 * received.1782 * 1783 * It's a no-op if any error on local XCM execution or message sending.1784 * Note sending assets out per se doesn't guarantee they would be1785 * received. Receiving depends on if the XCM message could be delivered1786 * by the network, and if the receiving chain would handle1787 * messages correctly.1788 **/1789 transfer: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, XcmVersionedMultiLocation, XcmV2WeightLimit]>;1790 /**1791 * Transfer `MultiAsset`.1792 * 1793 * `dest_weight_limit` is the weight for XCM execution on the dest1794 * chain, and it would be charged from the transferred assets. If set1795 * below requirements, the execution may fail and assets wouldn't be1796 * received.1797 * 1798 * It's a no-op if any error on local XCM execution or message sending.1799 * Note sending assets out per se doesn't guarantee they would be1800 * received. Receiving depends on if the XCM message could be delivered1801 * by the network, and if the receiving chain would handle1802 * messages correctly.1803 **/1804 transferMultiasset: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiLocation, XcmV2WeightLimit]>;1805 /**1806 * Transfer several `MultiAsset` specifying the item to be used as fee1807 * 1808 * `dest_weight_limit` is the weight for XCM execution on the dest1809 * chain, and it would be charged from the transferred assets. If set1810 * below requirements, the execution may fail and assets wouldn't be1811 * received.1812 * 1813 * `fee_item` is index of the MultiAssets that we want to use for1814 * payment1815 * 1816 * It's a no-op if any error on local XCM execution or message sending.1817 * Note sending assets out per se doesn't guarantee they would be1818 * received. Receiving depends on if the XCM message could be delivered1819 * by the network, and if the receiving chain would handle1820 * messages correctly.1821 **/1822 transferMultiassets: AugmentedSubmittable<(assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAssets, u32, XcmVersionedMultiLocation, XcmV2WeightLimit]>;1823 /**1824 * Transfer `MultiAsset` specifying the fee and amount as separate.1825 * 1826 * `dest_weight_limit` is the weight for XCM execution on the dest1827 * chain, and it would be charged from the transferred assets. If set1828 * below requirements, the execution may fail and assets wouldn't be1829 * received.1830 * 1831 * `fee` is the multiasset to be spent to pay for execution in1832 * destination chain. Both fee and amount will be subtracted form the1833 * callers balance For now we only accept fee and asset having the same1834 * `MultiLocation` id.1835 * 1836 * If `fee` is not high enough to cover for the execution costs in the1837 * destination chain, then the assets will be trapped in the1838 * destination chain1839 * 1840 * It's a no-op if any error on local XCM execution or message sending.1841 * Note sending assets out per se doesn't guarantee they would be1842 * received. Receiving depends on if the XCM message could be delivered1843 * by the network, and if the receiving chain would handle1844 * messages correctly.1845 **/1846 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, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiAsset, XcmVersionedMultiLocation, XcmV2WeightLimit]>;1847 /**1848 * Transfer several currencies specifying the item to be used as fee1849 * 1850 * `dest_weight_limit` is the weight for XCM execution on the dest1851 * chain, and it would be charged from the transferred assets. If set1852 * below requirements, the execution may fail and assets wouldn't be1853 * received.1854 * 1855 * `fee_item` is index of the currencies tuple that we want to use for1856 * payment1857 * 1858 * It's a no-op if any error on local XCM execution or message sending.1859 * Note sending assets out per se doesn't guarantee they would be1860 * received. Receiving depends on if the XCM message could be delivered1861 * by the network, and if the receiving chain would handle1862 * messages correctly.1863 **/1864 transferMulticurrencies: AugmentedSubmittable<(currencies: Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>> | ([PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, u128 | AnyNumber | Uint8Array])[], feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>>, u32, XcmVersionedMultiLocation, XcmV2WeightLimit]>;1865 /**1866 * Transfer native currencies specifying the fee and amount as1867 * separate.1868 * 1869 * `dest_weight_limit` is the weight for XCM execution on the dest1870 * chain, and it would be charged from the transferred assets. If set1871 * below requirements, the execution may fail and assets wouldn't be1872 * received.1873 * 1874 * `fee` is the amount to be spent to pay for execution in destination1875 * chain. Both fee and amount will be subtracted form the callers1876 * balance.1877 * 1878 * If `fee` is not high enough to cover for the execution costs in the1879 * destination chain, then the assets will be trapped in the1880 * destination chain1881 * 1882 * It's a no-op if any error on local XCM execution or message sending.1883 * Note sending assets out per se doesn't guarantee they would be1884 * received. Receiving depends on if the XCM message could be delivered1885 * by the network, and if the receiving chain would handle1886 * messages correctly.1887 **/1888 transferWithFee: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, fee: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, u128, XcmVersionedMultiLocation, XcmV2WeightLimit]>;1889 /**1890 * Generic tx1891 **/1892 [key: string]: SubmittableExtrinsicFunction<ApiType>;1893 };1894 } // AugmentedSubmittables1895} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts103.6 KiBsourcehistory