1// Auto-generated via `yarn polkadot-types-from-chain`, do not edit2/* eslint-disable */34import type { ApiTypes } from '@polkadot/api-base/types';5import type { Bytes, Compact, Option, U256, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';6import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';7import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill } from '@polkadot/types/interfaces/runtime';8import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, FrameSupportScheduleMaybeHashed, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';910declare module '@polkadot/api-base/types/submittable' {11 export interface AugmentedSubmittables<ApiType extends ApiTypes> {12 balances: {13 /**14 * Exactly as `transfer`, except the origin must be root and the source account may be15 * specified.16 * # <weight>17 * - Same as transfer, but additional read and write because the source account is not18 * assumed to be in the overlay.19 * # </weight>20 **/21 forceTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, Compact<u128>]>;22 /**23 * Unreserve some balance from a user by force.24 * 25 * Can only be called by ROOT.26 **/27 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;28 /**29 * Set the balances of a given account.30 * 31 * This will alter `FreeBalance` and `ReservedBalance` in storage. it will32 * also alter the total issuance of the system (`TotalIssuance`) appropriately.33 * If the new free or reserved balance is below the existential deposit,34 * it will reset the account nonce (`frame_system::AccountNonce`).35 * 36 * The dispatch origin for this call is `root`.37 **/38 setBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, newReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>, Compact<u128>]>;39 /**40 * Transfer some liquid free balance to another account.41 * 42 * `transfer` will set the `FreeBalance` of the sender and receiver.43 * If the sender's account is below the existential deposit as a result44 * of the transfer, the account will be reaped.45 * 46 * The dispatch origin for this call must be `Signed` by the transactor.47 * 48 * # <weight>49 * - Dependent on arguments but not critical, given proper implementations for input config50 * types. See related functions below.51 * - It contains a limited number of reads and writes internally and no complex52 * computation.53 * 54 * Related functions:55 * 56 * - `ensure_can_withdraw` is always called internally but has a bounded complexity.57 * - Transferring balances to accounts that did not exist before will cause58 * `T::OnNewAccount::on_new_account` to be called.59 * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.60 * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check61 * that the transfer will not kill the origin account.62 * ---------------------------------63 * - Origin account is already in memory, so no DB operations for them.64 * # </weight>65 **/66 transfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;67 /**68 * Transfer the entire transferable balance from the caller account.69 * 70 * NOTE: This function only attempts to transfer _transferable_ balances. This means that71 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be72 * transferred by this function. To ensure that this function results in a killed account,73 * you might need to prepare the account by removing any reference counters, storage74 * deposits, etc...75 * 76 * The dispatch origin of this call must be Signed.77 * 78 * - `dest`: The recipient of the transfer.79 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all80 * of the funds the account has, causing the sender account to be killed (false), or81 * transfer everything except at least the existential deposit, which will guarantee to82 * keep the sender account alive (true). # <weight>83 * - O(1). Just like transfer, but reading the user's transferable balance first.84 * #</weight>85 **/86 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;87 /**88 * Same as the [`transfer`] call, but with a check that the transfer will not kill the89 * origin account.90 * 91 * 99% of the time you want [`transfer`] instead.92 * 93 * [`transfer`]: struct.Pallet.html#method.transfer94 **/95 transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;96 /**97 * Generic tx98 **/99 [key: string]: SubmittableExtrinsicFunction<ApiType>;100 };101 charging: {102 /**103 * Generic tx104 **/105 [key: string]: SubmittableExtrinsicFunction<ApiType>;106 };107 configuration: {108 setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;109 setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u32> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;110 /**111 * Generic tx112 **/113 [key: string]: SubmittableExtrinsicFunction<ApiType>;114 };115 cumulusXcm: {116 /**117 * Generic tx118 **/119 [key: string]: SubmittableExtrinsicFunction<ApiType>;120 };121 dmpQueue: {122 /**123 * Service a single overweight message.124 * 125 * - `origin`: Must pass `ExecuteOverweightOrigin`.126 * - `index`: The index of the overweight message to service.127 * - `weight_limit`: The amount of weight that message execution may take.128 * 129 * Errors:130 * - `Unknown`: Message of `index` is unknown.131 * - `OverLimit`: Message execution may use greater than `weight_limit`.132 * 133 * Events:134 * - `OverweightServiced`: On success.135 **/136 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;137 /**138 * Generic tx139 **/140 [key: string]: SubmittableExtrinsicFunction<ApiType>;141 };142 ethereum: {143 /**144 * Transact an Ethereum transaction.145 **/146 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;147 /**148 * Generic tx149 **/150 [key: string]: SubmittableExtrinsicFunction<ApiType>;151 };152 evm: {153 /**154 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.155 **/156 call: AugmentedSubmittable<(source: H160 | string | Uint8Array, target: H160 | string | Uint8Array, input: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | object | string | Uint8Array, nonce: Option<U256> | null | object | string | Uint8Array, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, H160, Bytes, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;157 /**158 * Issue an EVM create operation. This is similar to a contract creation transaction in159 * Ethereum.160 **/161 create: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | object | string | Uint8Array, nonce: Option<U256> | null | object | string | Uint8Array, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, Bytes, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;162 /**163 * Issue an EVM create2 operation.164 **/165 create2: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, salt: H256 | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | object | string | Uint8Array, nonce: Option<U256> | null | object | string | Uint8Array, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, Bytes, H256, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;166 /**167 * Withdraw balance from EVM into currency/balances pallet.168 **/169 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;170 /**171 * Generic tx172 **/173 [key: string]: SubmittableExtrinsicFunction<ApiType>;174 };175 evmMigration: {176 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;177 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;178 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;179 /**180 * Generic tx181 **/182 [key: string]: SubmittableExtrinsicFunction<ApiType>;183 };184 inflation: {185 /**186 * This method sets the inflation start date. Can be only called once.187 * Inflation start block can be backdated and will catch up. The method will create Treasury188 * account if it does not exist and perform the first inflation deposit.189 * 190 * # Permissions191 * 192 * * Root193 * 194 * # Arguments195 * 196 * * inflation_start_relay_block: The relay chain block at which inflation should start197 **/198 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;199 /**200 * Generic tx201 **/202 [key: string]: SubmittableExtrinsicFunction<ApiType>;203 };204 parachainSystem: {205 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;206 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;207 /**208 * Set the current validation data.209 * 210 * This should be invoked exactly once per block. It will panic at the finalization211 * phase if the call was not invoked.212 * 213 * The dispatch origin for this call must be `Inherent`214 * 215 * As a side effect, this function upgrades the current validation function216 * if the appropriate time has come.217 **/218 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;219 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;220 /**221 * Generic tx222 **/223 [key: string]: SubmittableExtrinsicFunction<ApiType>;224 };225 polkadotXcm: {226 /**227 * Execute an XCM message from a local, signed, origin.228 * 229 * An event is deposited indicating whether `msg` could be executed completely or only230 * partially.231 * 232 * No more than `max_weight` will be used in its attempted execution. If this is less than the233 * maximum amount of weight that the message could take to be executed, then no execution234 * attempt will be made.235 * 236 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully237 * to completion; only that *some* of it was executed.238 **/239 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;240 /**241 * Set a safe XCM version (the version that XCM should be encoded with if the most recent242 * version a destination can accept is unknown).243 * 244 * - `origin`: Must be Root.245 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.246 **/247 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;248 /**249 * Ask a location to notify us regarding their XCM version and any changes to it.250 * 251 * - `origin`: Must be Root.252 * - `location`: The location to which we should subscribe for XCM version notifications.253 **/254 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;255 /**256 * Require that a particular destination should no longer notify us regarding any XCM257 * version changes.258 * 259 * - `origin`: Must be Root.260 * - `location`: The location to which we are currently subscribed for XCM version261 * notifications which we no longer desire.262 **/263 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;264 /**265 * Extoll that a particular destination can be communicated with through a particular266 * version of XCM.267 * 268 * - `origin`: Must be Root.269 * - `location`: The destination that is being described.270 * - `xcm_version`: The latest version of XCM that `location` supports.271 **/272 forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;273 /**274 * Transfer some assets from the local chain to the sovereign account of a destination275 * chain and forward a notification XCM.276 * 277 * Fee payment on the destination side is made from the asset in the `assets` vector of278 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight279 * is needed than `weight_limit`, then the operation will fail and the assets send may be280 * at risk.281 * 282 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.283 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send284 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.285 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be286 * an `AccountId32` value.287 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the288 * `dest` side.289 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay290 * fees.291 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.292 **/293 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]>;294 /**295 * Teleport some assets from the local chain to some destination chain.296 * 297 * Fee payment on the destination side is made from the asset in the `assets` vector of298 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight299 * is needed than `weight_limit`, then the operation will fail and the assets send may be300 * at risk.301 * 302 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.303 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send304 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.305 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be306 * an `AccountId32` value.307 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the308 * `dest` side. May not be empty.309 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay310 * fees.311 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.312 **/313 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]>;314 /**315 * Transfer some assets from the local chain to the sovereign account of a destination316 * chain and forward a notification XCM.317 * 318 * Fee payment on the destination side is made from the asset in the `assets` vector of319 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,320 * with all fees taken as needed from the asset.321 * 322 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.323 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send324 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.325 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be326 * an `AccountId32` value.327 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the328 * `dest` side.329 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay330 * fees.331 **/332 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]>;333 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;334 /**335 * Teleport some assets from the local chain to some destination chain.336 * 337 * Fee payment on the destination side is made from the asset in the `assets` vector of338 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,339 * with all fees taken as needed from the asset.340 * 341 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.342 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send343 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.344 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be345 * an `AccountId32` value.346 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the347 * `dest` side. May not be empty.348 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay349 * fees.350 **/351 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]>;352 /**353 * Generic tx354 **/355 [key: string]: SubmittableExtrinsicFunction<ApiType>;356 };357 rmrkCore: {358 /**359 * Accept an NFT sent from another account to self or an owned NFT.360 * 361 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.362 * 363 * # Permissions:364 * - Token-owner-to-be365 * 366 * # Arguments:367 * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.368 * - `rmrk_nft_id`: ID of the NFT to be accepted.369 * - `new_owner`: Either the sender's account ID or a sender-owned NFT,370 * whichever the accepted NFT was sent to.371 **/372 acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;373 /**374 * Accept the addition of a newly created pending resource to an existing NFT.375 * 376 * This transaction is needed when a resource is created and assigned to an NFT377 * by a non-owner, i.e. the collection issuer, with one of the378 * [`add_...` transactions](Pallet::add_basic_resource).379 * 380 * # Permissions:381 * - Token owner382 * 383 * # Arguments:384 * - `rmrk_collection_id`: RMRK collection ID of the NFT.385 * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.386 * - `resource_id`: ID of the newly created pending resource.387 **/388 acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;389 /**390 * Accept the removal of a removal-pending resource from an NFT.391 * 392 * This transaction is needed when a non-owner, i.e. the collection issuer,393 * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.394 * 395 * # Permissions:396 * - Token owner397 * 398 * # Arguments:399 * - `rmrk_collection_id`: RMRK collection ID of the NFT.400 * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.401 * - `resource_id`: ID of the removal-pending resource.402 **/403 acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;404 /**405 * Create and set/propose a basic resource for an NFT.406 * 407 * A basic resource is the simplest, lacking a Base and anything that comes with it.408 * See RMRK docs for more information and examples.409 * 410 * # Permissions:411 * - Collection issuer - if not the token owner, adding the resource will warrant412 * the owner's [acceptance](Pallet::accept_resource).413 * 414 * # Arguments:415 * - `rmrk_collection_id`: RMRK collection ID of the NFT.416 * - `nft_id`: ID of the NFT to assign a resource to.417 * - `resource`: Data of the resource to be created.418 **/419 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]>;420 /**421 * Create and set/propose a composable resource for an NFT.422 * 423 * A composable resource links to a Base and has a subset of its Parts it is composed of.424 * See RMRK docs for more information and examples.425 * 426 * # Permissions:427 * - Collection issuer - if not the token owner, adding the resource will warrant428 * the owner's [acceptance](Pallet::accept_resource).429 * 430 * # Arguments:431 * - `rmrk_collection_id`: RMRK collection ID of the NFT.432 * - `nft_id`: ID of the NFT to assign a resource to.433 * - `resource`: Data of the resource to be created.434 **/435 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]>;436 /**437 * Create and set/propose a slot resource for an NFT.438 * 439 * A slot resource links to a Base and a slot ID in it which it can fit into.440 * See RMRK docs for more information and examples.441 * 442 * # Permissions:443 * - Collection issuer - if not the token owner, adding the resource will warrant444 * the owner's [acceptance](Pallet::accept_resource).445 * 446 * # Arguments:447 * - `rmrk_collection_id`: RMRK collection ID of the NFT.448 * - `nft_id`: ID of the NFT to assign a resource to.449 * - `resource`: Data of the resource to be created.450 **/451 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]>;452 /**453 * Burn an NFT, destroying it and its nested tokens up to the specified limit.454 * If the burning budget is exceeded, the transaction is reverted.455 * 456 * This is the way to burn a nested token as well.457 * 458 * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).459 * 460 * # Permissions:461 * * Token owner462 * 463 * # Arguments:464 * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.465 * - `nft_id`: ID of the NFT to be destroyed.466 * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction467 * is reverted if there are more tokens to burn in the nesting tree than this number.468 * This is primarily a mechanism of transaction weight control.469 **/470 burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;471 /**472 * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).473 * 474 * # Permissions:475 * * Collection issuer476 * 477 * # Arguments:478 * - `collection_id`: RMRK collection ID to change the issuer of.479 * - `new_issuer`: Collection's new issuer.480 **/481 changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;482 /**483 * Create a new collection of NFTs.484 * 485 * # Permissions:486 * * Anyone - will be assigned as the issuer of the collection.487 * 488 * # Arguments:489 * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.490 * - `max`: Optional maximum number of tokens.491 * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.492 * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.493 **/494 createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | object | string | Uint8Array, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;495 /**496 * Destroy a collection.497 * 498 * Only empty collections can be destroyed. If it has any tokens, they must be burned first.499 * 500 * # Permissions:501 * * Collection issuer502 * 503 * # Arguments:504 * - `collection_id`: RMRK ID of the collection to destroy.505 **/506 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;507 /**508 * "Lock" the collection and prevent new token creation. Cannot be undone.509 * 510 * # Permissions:511 * * Collection issuer512 * 513 * # Arguments:514 * - `collection_id`: RMRK ID of the collection to lock.515 **/516 lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;517 /**518 * Mint an NFT in a specified collection.519 * 520 * # Permissions:521 * * Collection issuer522 * 523 * # Arguments:524 * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).525 * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.526 * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.527 * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.528 * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.529 * - `transferable`: Can this NFT be transferred? Cannot be changed.530 * - `resources`: Resource data to be added to the NFT immediately after minting.531 **/532 mintNft: AugmentedSubmittable<(owner: Option<AccountId32> | null | object | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, recipient: Option<AccountId32> | null | object | string | Uint8Array, royaltyAmount: Option<Permill> | null | object | string | Uint8Array, metadata: Bytes | string | Uint8Array, transferable: bool | boolean | Uint8Array, resources: Option<Vec<RmrkTraitsResourceResourceTypes>> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<AccountId32>, u32, Option<AccountId32>, Option<Permill>, Bytes, bool, Option<Vec<RmrkTraitsResourceResourceTypes>>]>;533 /**534 * Reject an NFT sent from another account to self or owned NFT.535 * The NFT in question will not be sent back and burnt instead.536 * 537 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.538 * 539 * # Permissions:540 * - Token-owner-to-be-not541 * 542 * # Arguments:543 * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.544 * - `rmrk_nft_id`: ID of the NFT to be rejected.545 **/546 rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;547 /**548 * Remove and erase a resource from an NFT.549 * 550 * If the sender does not own the NFT, then it will be pending confirmation,551 * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.552 * 553 * # Permissions554 * - Collection issuer555 * 556 * # Arguments557 * - `collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.558 * - `nft_id`: ID of the NFT with a resource to be removed.559 * - `resource_id`: ID of the resource to be removed.560 **/561 removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;562 /**563 * Transfer an NFT from an account/NFT A to another account/NFT B.564 * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].565 * 566 * If the target owner is an NFT owned by another account, then the NFT will enter567 * the pending state and will have to be accepted by the other account.568 * 569 * # Permissions:570 * - Token owner571 * 572 * # Arguments:573 * - `collection_id`: RMRK ID of the collection of the NFT to be transferred.574 * - `nft_id`: ID of the NFT to be transferred.575 * - `new_owner`: New owner of the nft which can be either an account or a NFT.576 **/577 send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;578 /**579 * Set a different order of resource priorities for an NFT. Priorities can be used,580 * for example, for order of rendering.581 * 582 * Note that the priorities are not updated automatically, and are an empty vector583 * by default. There is no pre-set definition for the order to be particular,584 * it can be interpreted arbitrarily use-case by use-case.585 * 586 * # Permissions:587 * - Token owner588 * 589 * # Arguments:590 * - `rmrk_collection_id`: RMRK collection ID of the NFT.591 * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.592 * - `priorities`: Ordered vector of resource IDs.593 **/594 setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;595 /**596 * Add or edit a custom user property, a key-value pair, describing the metadata597 * of a token or a collection, on either one of these.598 * 599 * Note that in this proxy implementation many details regarding RMRK are stored600 * as scoped properties prefixed with "rmrk:", normally inaccessible601 * to external transactions and RPCs.602 * 603 * # Permissions:604 * - Collection issuer - in case of collection property605 * - Token owner - in case of NFT property606 * 607 * # Arguments:608 * - `rmrk_collection_id`: RMRK collection ID.609 * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.610 * - `key`: Key of the custom property to be referenced by.611 * - `value`: Value of the custom property to be stored.612 **/613 setProperty: AugmentedSubmittable<(rmrkCollectionId: Compact<u32> | AnyNumber | Uint8Array, maybeNftId: Option<u32> | null | object | string | Uint8Array, key: Bytes | string | Uint8Array, value: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Option<u32>, Bytes, Bytes]>;614 /**615 * Generic tx616 **/617 [key: string]: SubmittableExtrinsicFunction<ApiType>;618 };619 rmrkEquip: {620 /**621 * Create a new Base.622 * 623 * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)624 * 625 * # Permissions626 * - Anyone - will be assigned as the issuer of the Base.627 * 628 * # Arguments:629 * - `base_type`: Arbitrary media type, e.g. "svg".630 * - `symbol`: Arbitrary client-chosen symbol.631 * - `parts`: Array of Fixed and Slot Parts composing the Base,632 * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).633 **/634 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>]>;635 /**636 * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.637 * 638 * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).639 * 640 * # Permissions:641 * - Base issuer642 * 643 * # Arguments:644 * - `base_id`: Base containing the Slot Part to be updated.645 * - `part_id`: Slot Part whose Equippable List is being updated.646 * - `equippables`: List of equippables that will override the current Equippables list.647 **/648 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]>;649 /**650 * Add a Theme to a Base.651 * A Theme named "default" is required prior to adding other Themes.652 * 653 * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).654 * 655 * # Permissions:656 * - Base issuer657 * 658 * # Arguments:659 * - `base_id`: Base ID containing the Theme to be updated.660 * - `theme`: Theme to add to the Base. A Theme has a name and properties, which are an661 * array of [key, value, inherit].662 * - `key`: Arbitrary BoundedString, defined by client.663 * - `value`: Arbitrary BoundedString, defined by client.664 * - `inherit`: Optional bool.665 **/666 themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;667 /**668 * Generic tx669 **/670 [key: string]: SubmittableExtrinsicFunction<ApiType>;671 };672 scheduler: {673 /**674 * Cancel a named scheduled task.675 **/676 cancelNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed]>;677 /**678 * Schedule a named task.679 **/680 scheduleNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | object | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, FrameSupportScheduleMaybeHashed]>;681 /**682 * Schedule a named task after a delay.683 * 684 * # <weight>685 * Same as [`schedule_named`](Self::schedule_named).686 * # </weight>687 **/688 scheduleNamedAfter: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | object | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, FrameSupportScheduleMaybeHashed]>;689 /**690 * Generic tx691 **/692 [key: string]: SubmittableExtrinsicFunction<ApiType>;693 };694 structure: {695 /**696 * Generic tx697 **/698 [key: string]: SubmittableExtrinsicFunction<ApiType>;699 };700 sudo: {701 /**702 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo703 * key.704 * 705 * The dispatch origin for this call must be _Signed_.706 * 707 * # <weight>708 * - O(1).709 * - Limited storage reads.710 * - One DB change.711 * # </weight>712 **/713 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;714 /**715 * Authenticates the sudo key and dispatches a function call with `Root` origin.716 * 717 * The dispatch origin for this call must be _Signed_.718 * 719 * # <weight>720 * - O(1).721 * - Limited storage reads.722 * - One DB write (event).723 * - Weight of derivative `call` execution + 10,000.724 * # </weight>725 **/726 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;727 /**728 * Authenticates the sudo key and dispatches a function call with `Signed` origin from729 * a given account.730 * 731 * The dispatch origin for this call must be _Signed_.732 * 733 * # <weight>734 * - O(1).735 * - Limited storage reads.736 * - One DB write (event).737 * - Weight of derivative `call` execution + 10,000.738 * # </weight>739 **/740 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]>;741 /**742 * Authenticates the sudo key and dispatches a function call with `Root` origin.743 * This function does not check the weight of the call, and instead allows the744 * Sudo user to specify the weight of the call.745 * 746 * The dispatch origin for this call must be _Signed_.747 * 748 * # <weight>749 * - O(1).750 * - The weight of this call is defined by the caller.751 * # </weight>752 **/753 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, u64]>;754 /**755 * Generic tx756 **/757 [key: string]: SubmittableExtrinsicFunction<ApiType>;758 };759 system: {760 /**761 * A dispatch that will fill the block weight up to the given ratio.762 **/763 fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;764 /**765 * Kill all storage items with a key that starts with the given prefix.766 * 767 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under768 * the prefix we are removing to accurately calculate the weight of this function.769 **/770 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;771 /**772 * Kill some items from storage.773 **/774 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;775 /**776 * Make some on-chain remark.777 * 778 * # <weight>779 * - `O(1)`780 * # </weight>781 **/782 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;783 /**784 * Make some on-chain remark and emit event.785 **/786 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;787 /**788 * Set the new runtime code.789 * 790 * # <weight>791 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`792 * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is793 * expensive).794 * - 1 storage write (codec `O(C)`).795 * - 1 digest item.796 * - 1 event.797 * The weight of this function is dependent on the runtime, but generally this is very798 * expensive. We will treat this as a full block.799 * # </weight>800 **/801 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;802 /**803 * Set the new runtime code without doing any checks of the given `code`.804 * 805 * # <weight>806 * - `O(C)` where `C` length of `code`807 * - 1 storage write (codec `O(C)`).808 * - 1 digest item.809 * - 1 event.810 * The weight of this function is dependent on the runtime. We will treat this as a full811 * block. # </weight>812 **/813 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;814 /**815 * Set the number of pages in the WebAssembly environment's heap.816 **/817 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;818 /**819 * Set some items of storage.820 **/821 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;822 /**823 * Generic tx824 **/825 [key: string]: SubmittableExtrinsicFunction<ApiType>;826 };827 timestamp: {828 /**829 * Set the current time.830 * 831 * This call should be invoked exactly once per block. It will panic at the finalization832 * phase, if this call hasn't been invoked by that time.833 * 834 * The timestamp should be greater than the previous one by the amount specified by835 * `MinimumPeriod`.836 * 837 * The dispatch origin for this call must be `Inherent`.838 * 839 * # <weight>840 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)841 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in842 * `on_finalize`)843 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.844 * # </weight>845 **/846 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;847 /**848 * Generic tx849 **/850 [key: string]: SubmittableExtrinsicFunction<ApiType>;851 };852 treasury: {853 /**854 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary855 * and the original deposit will be returned.856 * 857 * May only be called from `T::ApproveOrigin`.858 * 859 * # <weight>860 * - Complexity: O(1).861 * - DbReads: `Proposals`, `Approvals`862 * - DbWrite: `Approvals`863 * # </weight>864 **/865 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;866 /**867 * Put forward a suggestion for spending. A deposit proportional to the value868 * is reserved and slashed if the proposal is rejected. It is returned once the869 * proposal is awarded.870 * 871 * # <weight>872 * - Complexity: O(1)873 * - DbReads: `ProposalCount`, `origin account`874 * - DbWrites: `ProposalCount`, `Proposals`, `origin account`875 * # </weight>876 **/877 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]>;878 /**879 * Reject a proposed spend. The original deposit will be slashed.880 * 881 * May only be called from `T::RejectOrigin`.882 * 883 * # <weight>884 * - Complexity: O(1)885 * - DbReads: `Proposals`, `rejected proposer account`886 * - DbWrites: `Proposals`, `rejected proposer account`887 * # </weight>888 **/889 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;890 /**891 * Force a previously approved proposal to be removed from the approval queue.892 * The original deposit will no longer be returned.893 * 894 * May only be called from `T::RejectOrigin`.895 * - `proposal_id`: The index of a proposal896 * 897 * # <weight>898 * - Complexity: O(A) where `A` is the number of approvals899 * - Db reads and writes: `Approvals`900 * # </weight>901 * 902 * Errors:903 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,904 * i.e., the proposal has not been approved. This could also mean the proposal does not905 * exist altogether, thus there is no way it would have been approved in the first place.906 **/907 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;908 /**909 * Generic tx910 **/911 [key: string]: SubmittableExtrinsicFunction<ApiType>;912 };913 unique: {914 /**915 * Add an admin to a collection.916 * 917 * NFT Collection can be controlled by multiple admin addresses918 * (some which can also be servers, for example). Admins can issue919 * and burn NFTs, as well as add and remove other admins,920 * but cannot change NFT or Collection ownership.921 * 922 * # Permissions923 * 924 * * Collection owner925 * * Collection admin926 * 927 * # Arguments928 * 929 * * `collection_id`: ID of the Collection to add an admin for.930 * * `new_admin`: Address of new admin to add.931 **/932 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdmin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;933 /**934 * Add an address to allow list.935 * 936 * # Permissions937 * 938 * * Collection owner939 * * Collection admin940 * 941 * # Arguments942 * 943 * * `collection_id`: ID of the modified collection.944 * * `address`: ID of the address to be added to the allowlist.945 **/946 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;947 /**948 * Allow a non-permissioned address to transfer or burn an item.949 * 950 * # Permissions951 * 952 * * Collection owner953 * * Collection admin954 * * Current item owner955 * 956 * # Arguments957 * 958 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.959 * * `collection_id`: ID of the collection the item belongs to.960 * * `item_id`: ID of the item transactions on which are now approved.961 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).962 * Set to 0 to revoke the approval.963 **/964 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]>;965 /**966 * Destroy a token on behalf of the owner as a non-owner account.967 * 968 * See also: [`approve`][`Pallet::approve`].969 * 970 * After this method executes, one approval is removed from the total so that971 * the approved address will not be able to transfer this item again from this owner.972 * 973 * # Permissions974 * 975 * * Collection owner976 * * Collection admin977 * * Current token owner978 * * Address approved by current item owner979 * 980 * # Arguments981 * 982 * * `from`: The owner of the burning item.983 * * `collection_id`: ID of the collection to which the item belongs.984 * * `item_id`: ID of item to burn.985 * * `value`: Number of pieces to burn.986 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.987 * * Fungible Mode: The desired number of pieces to burn.988 * * Re-Fungible Mode: The desired number of pieces to burn.989 **/990 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]>;991 /**992 * Destroy an item.993 * 994 * # Permissions995 * 996 * * Collection owner997 * * Collection admin998 * * Current item owner999 * 1000 * # Arguments1001 * 1002 * * `collection_id`: ID of the collection to which the item belongs.1003 * * `item_id`: ID of item to burn.1004 * * `value`: Number of pieces of the item to destroy.1005 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1006 * * Fungible Mode: The desired number of pieces to burn.1007 * * Re-Fungible Mode: The desired number of pieces to burn.1008 **/1009 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1010 /**1011 * Change the owner of the collection.1012 * 1013 * # Permissions1014 * 1015 * * Collection owner1016 * 1017 * # Arguments1018 * 1019 * * `collection_id`: ID of the modified collection.1020 * * `new_owner`: ID of the account that will become the owner.1021 **/1022 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1023 /**1024 * Confirm own sponsorship of a collection, becoming the sponsor.1025 * 1026 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1027 * Sponsor can pay the fees of a transaction instead of the sender,1028 * but only within specified limits.1029 * 1030 * # Permissions1031 * 1032 * * Sponsor-to-be1033 * 1034 * # Arguments1035 * 1036 * * `collection_id`: ID of the collection with the pending sponsor.1037 **/1038 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1039 /**1040 * Create a collection of tokens.1041 * 1042 * Each Token may have multiple properties encoded as an array of bytes1043 * of certain length. The initial owner of the collection is set1044 * to the address that signed the transaction and can be changed later.1045 * 1046 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1047 * 1048 * # Permissions1049 * 1050 * * Anyone - becomes the owner of the new collection.1051 * 1052 * # Arguments1053 * 1054 * * `collection_name`: Wide-character string with collection name1055 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1056 * * `collection_description`: Wide-character string with collection description1057 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1058 * * `token_prefix`: Byte string containing the token prefix to mark a collection1059 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1060 * * `mode`: Type of items stored in the collection and type dependent data.1061 **/1062 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]>;1063 /**1064 * Create a collection with explicit parameters.1065 * 1066 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1067 * 1068 * # Permissions1069 * 1070 * * Anyone - becomes the owner of the new collection.1071 * 1072 * # Arguments1073 * 1074 * * `data`: Explicit data of a collection used for its creation.1075 **/1076 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]>;1077 /**1078 * Mint an item within a collection.1079 * 1080 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1081 * 1082 * # Permissions1083 * 1084 * * Collection owner1085 * * Collection admin1086 * * Anyone if1087 * * Allow List is enabled, and1088 * * Address is added to allow list, and1089 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1090 * 1091 * # Arguments1092 * 1093 * * `collection_id`: ID of the collection to which an item would belong.1094 * * `owner`: Address of the initial owner of the item.1095 * * `data`: Token data describing the item to store on chain.1096 **/1097 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]>;1098 /**1099 * Create multiple items within a collection.1100 * 1101 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1102 * 1103 * # Permissions1104 * 1105 * * Collection owner1106 * * Collection admin1107 * * Anyone if1108 * * Allow List is enabled, and1109 * * Address is added to the allow list, and1110 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1111 * 1112 * # Arguments1113 * 1114 * * `collection_id`: ID of the collection to which the tokens would belong.1115 * * `owner`: Address of the initial owner of the tokens.1116 * * `items_data`: Vector of data describing each item to be created.1117 **/1118 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>]>;1119 /**1120 * Create multiple items within a collection with explicitly specified initial parameters.1121 * 1122 * # Permissions1123 * 1124 * * Collection owner1125 * * Collection admin1126 * * Anyone if1127 * * Allow List is enabled, and1128 * * Address is added to allow list, and1129 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1130 * 1131 * # Arguments1132 * 1133 * * `collection_id`: ID of the collection to which the tokens would belong.1134 * * `data`: Explicit item creation data.1135 **/1136 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1137 /**1138 * Delete specified collection properties.1139 * 1140 * # Permissions1141 * 1142 * * Collection Owner1143 * * Collection Admin1144 * 1145 * # Arguments1146 * 1147 * * `collection_id`: ID of the modified collection.1148 * * `property_keys`: Vector of keys of the properties to be deleted.1149 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1150 **/1151 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1152 /**1153 * Delete specified token properties. Currently properties only work with NFTs.1154 * 1155 * # Permissions1156 * 1157 * * Depends on collection's token property permissions and specified property mutability:1158 * * Collection owner1159 * * Collection admin1160 * * Token owner1161 * 1162 * # Arguments1163 * 1164 * * `collection_id`: ID of the collection to which the token belongs.1165 * * `token_id`: ID of the modified token.1166 * * `property_keys`: Vector of keys of the properties to be deleted.1167 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1168 **/1169 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1170 /**1171 * Destroy a collection if no tokens exist within.1172 * 1173 * # Permissions1174 * 1175 * * Collection owner1176 * 1177 * # Arguments1178 * 1179 * * `collection_id`: Collection to destroy.1180 **/1181 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1182 /**1183 * Remove admin of a collection.1184 * 1185 * An admin address can remove itself. List of admins may become empty,1186 * in which case only Collection Owner will be able to add an Admin.1187 * 1188 * # Permissions1189 * 1190 * * Collection owner1191 * * Collection admin1192 * 1193 * # Arguments1194 * 1195 * * `collection_id`: ID of the collection to remove the admin for.1196 * * `account_id`: Address of the admin to remove.1197 **/1198 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1199 /**1200 * Remove a collection's a sponsor, making everyone pay for their own transactions.1201 * 1202 * # Permissions1203 * 1204 * * Collection owner1205 * 1206 * # Arguments1207 * 1208 * * `collection_id`: ID of the collection with the sponsor to remove.1209 **/1210 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1211 /**1212 * Remove an address from allow list.1213 * 1214 * # Permissions1215 * 1216 * * Collection owner1217 * * Collection admin1218 * 1219 * # Arguments1220 * 1221 * * `collection_id`: ID of the modified collection.1222 * * `address`: ID of the address to be removed from the allowlist.1223 **/1224 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1225 /**1226 * Re-partition a refungible token, while owning all of its parts/pieces.1227 * 1228 * # Permissions1229 * 1230 * * Token owner (must own every part)1231 * 1232 * # Arguments1233 * 1234 * * `collection_id`: ID of the collection the RFT belongs to.1235 * * `token_id`: ID of the RFT.1236 * * `amount`: New number of parts/pieces into which the token shall be partitioned.1237 **/1238 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1239 /**1240 * Set specific limits of a collection. Empty, or None fields mean chain default.1241 * 1242 * # Permissions1243 * 1244 * * Collection owner1245 * * Collection admin1246 * 1247 * # Arguments1248 * 1249 * * `collection_id`: ID of the modified collection.1250 * * `new_limit`: New limits of the collection. Fields that are not set (None)1251 * will not overwrite the old ones.1252 **/1253 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]>;1254 /**1255 * Set specific permissions of a collection. Empty, or None fields mean chain default.1256 * 1257 * # Permissions1258 * 1259 * * Collection owner1260 * * Collection admin1261 * 1262 * # Arguments1263 * 1264 * * `collection_id`: ID of the modified collection.1265 * * `new_permission`: New permissions of the collection. Fields that are not set (None)1266 * will not overwrite the old ones.1267 **/1268 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1269 /**1270 * Add or change collection properties.1271 * 1272 * # Permissions1273 * 1274 * * Collection owner1275 * * Collection admin1276 * 1277 * # Arguments1278 * 1279 * * `collection_id`: ID of the modified collection.1280 * * `properties`: Vector of key-value pairs stored as the collection's metadata.1281 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1282 **/1283 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1284 /**1285 * Set (invite) a new collection sponsor.1286 * 1287 * If successful, confirmation from the sponsor-to-be will be pending.1288 * 1289 * # Permissions1290 * 1291 * * Collection owner1292 * * Collection admin1293 * 1294 * # Arguments1295 * 1296 * * `collection_id`: ID of the modified collection.1297 * * `new_sponsor`: ID of the account of the sponsor-to-be.1298 **/1299 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1300 /**1301 * Add or change token properties according to collection's permissions.1302 * Currently properties only work with NFTs.1303 * 1304 * # Permissions1305 * 1306 * * Depends on collection's token property permissions and specified property mutability:1307 * * Collection owner1308 * * Collection admin1309 * * Token owner1310 * 1311 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1312 * 1313 * # Arguments1314 * 1315 * * `collection_id: ID of the collection to which the token belongs.1316 * * `token_id`: ID of the modified token.1317 * * `properties`: Vector of key-value pairs stored as the token's metadata.1318 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1319 **/1320 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>]>;1321 /**1322 * Add or change token property permissions of a collection.1323 * 1324 * Without a permission for a particular key, a property with that key1325 * cannot be created in a token.1326 * 1327 * # Permissions1328 * 1329 * * Collection owner1330 * * Collection admin1331 * 1332 * # Arguments1333 * 1334 * * `collection_id`: ID of the modified collection.1335 * * `property_permissions`: Vector of permissions for property keys.1336 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1337 **/1338 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1339 /**1340 * Completely allow or disallow transfers for a particular collection.1341 * 1342 * # Permissions1343 * 1344 * * Collection owner1345 * 1346 * # Arguments1347 * 1348 * * `collection_id`: ID of the collection.1349 * * `value`: New value of the flag, are transfers allowed?1350 **/1351 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1352 /**1353 * Change ownership of the token.1354 * 1355 * # Permissions1356 * 1357 * * Collection owner1358 * * Collection admin1359 * * Current token owner1360 * 1361 * # Arguments1362 * 1363 * * `recipient`: Address of token recipient.1364 * * `collection_id`: ID of the collection the item belongs to.1365 * * `item_id`: ID of the item.1366 * * Non-Fungible Mode: Required.1367 * * Fungible Mode: Ignored.1368 * * Re-Fungible Mode: Required.1369 * 1370 * * `value`: Amount to transfer.1371 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1372 * * Fungible Mode: The desired number of pieces to transfer.1373 * * Re-Fungible Mode: The desired number of pieces to transfer.1374 **/1375 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]>;1376 /**1377 * Change ownership of an item on behalf of the owner as a non-owner account.1378 * 1379 * See the [`approve`][`Pallet::approve`] method for additional information.1380 * 1381 * After this method executes, one approval is removed from the total so that1382 * the approved address will not be able to transfer this item again from this owner.1383 * 1384 * # Permissions1385 * 1386 * * Collection owner1387 * * Collection admin1388 * * Current item owner1389 * * Address approved by current item owner1390 * 1391 * # Arguments1392 * 1393 * * `from`: Address that currently owns the token.1394 * * `recipient`: Address of the new token-owner-to-be.1395 * * `collection_id`: ID of the collection the item.1396 * * `item_id`: ID of the item to be transferred.1397 * * `value`: Amount to transfer.1398 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1399 * * Fungible Mode: The desired number of pieces to transfer.1400 * * Re-Fungible Mode: The desired number of pieces to transfer.1401 **/1402 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]>;1403 /**1404 * Generic tx1405 **/1406 [key: string]: SubmittableExtrinsicFunction<ApiType>;1407 };1408 vesting: {1409 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1410 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1411 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>]>;1412 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]>;1413 /**1414 * Generic tx1415 **/1416 [key: string]: SubmittableExtrinsicFunction<ApiType>;1417 };1418 xcmpQueue: {1419 /**1420 * Resumes all XCM executions for the XCMP queue.1421 * 1422 * Note that this function doesn't change the status of the in/out bound channels.1423 * 1424 * - `origin`: Must pass `ControllerOrigin`.1425 **/1426 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1427 /**1428 * Services a single overweight XCM.1429 * 1430 * - `origin`: Must pass `ExecuteOverweightOrigin`.1431 * - `index`: The index of the overweight XCM to service1432 * - `weight_limit`: The amount of weight that XCM execution may take.1433 * 1434 * Errors:1435 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1436 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1437 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1438 * 1439 * Events:1440 * - `OverweightServiced`: On success.1441 **/1442 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1443 /**1444 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1445 * 1446 * - `origin`: Must pass `ControllerOrigin`.1447 **/1448 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1449 /**1450 * Overwrites the number of pages of messages which must be in the queue after which we drop any further1451 * messages from the channel.1452 * 1453 * - `origin`: Must pass `Root`.1454 * - `new`: Desired value for `QueueConfigData.drop_threshold`1455 **/1456 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1457 /**1458 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1459 * message sending may recommence after it has been suspended.1460 * 1461 * - `origin`: Must pass `Root`.1462 * - `new`: Desired value for `QueueConfigData.resume_threshold`1463 **/1464 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1465 /**1466 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1467 * suspend their sending.1468 * 1469 * - `origin`: Must pass `Root`.1470 * - `new`: Desired value for `QueueConfigData.suspend_value`1471 **/1472 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1473 /**1474 * Overwrites the amount of remaining weight under which we stop processing messages.1475 * 1476 * - `origin`: Must pass `Root`.1477 * - `new`: Desired value for `QueueConfigData.threshold_weight`1478 **/1479 updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1480 /**1481 * Overwrites the speed to which the available weight approaches the maximum weight.1482 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1483 * 1484 * - `origin`: Must pass `Root`.1485 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1486 **/1487 updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1488 /**1489 * Overwrite the maximum amount of weight any individual message may consume.1490 * Messages above this weight go into the overweight queue and may only be serviced explicitly.1491 * 1492 * - `origin`: Must pass `Root`.1493 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1494 **/1495 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1496 /**1497 * Generic tx1498 **/1499 [key: string]: SubmittableExtrinsicFunction<ApiType>;1500 };1501 } // AugmentedSubmittables1502} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts80.9 KiBsourcehistory