git.delta.rocks / unique-network / refs/commits / 258c7f483482

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    cumulusXcm: {108      /**109       * Generic tx110       **/111      [key: string]: SubmittableExtrinsicFunction<ApiType>;112    };113    dmpQueue: {114      /**115       * Service a single overweight message.116       * 117       * - `origin`: Must pass `ExecuteOverweightOrigin`.118       * - `index`: The index of the overweight message to service.119       * - `weight_limit`: The amount of weight that message execution may take.120       * 121       * Errors:122       * - `Unknown`: Message of `index` is unknown.123       * - `OverLimit`: Message execution may use greater than `weight_limit`.124       * 125       * Events:126       * - `OverweightServiced`: On success.127       **/128      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;129      /**130       * Generic tx131       **/132      [key: string]: SubmittableExtrinsicFunction<ApiType>;133    };134    ethereum: {135      /**136       * Transact an Ethereum transaction.137       **/138      transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;139      /**140       * Generic tx141       **/142      [key: string]: SubmittableExtrinsicFunction<ApiType>;143    };144    evm: {145      /**146       * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.147       **/148      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>]>>]>;149      /**150       * Issue an EVM create operation. This is similar to a contract creation transaction in151       * Ethereum.152       **/153      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>]>>]>;154      /**155       * Issue an EVM create2 operation.156       **/157      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>]>>]>;158      /**159       * Withdraw balance from EVM into currency/balances pallet.160       **/161      withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;162      /**163       * Generic tx164       **/165      [key: string]: SubmittableExtrinsicFunction<ApiType>;166    };167    evmMigration: {168      begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;169      finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;170      setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;171      /**172       * Generic tx173       **/174      [key: string]: SubmittableExtrinsicFunction<ApiType>;175    };176    inflation: {177      /**178       * This method sets the inflation start date. Can be only called once.179       * Inflation start block can be backdated and will catch up. The method will create Treasury180       * account if it does not exist and perform the first inflation deposit.181       * 182       * # Permissions183       * 184       * * Root185       * 186       * # Arguments187       * 188       * * inflation_start_relay_block: The relay chain block at which inflation should start189       **/190      startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;191      /**192       * Generic tx193       **/194      [key: string]: SubmittableExtrinsicFunction<ApiType>;195    };196    parachainSystem: {197      authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;198      enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;199      /**200       * Set the current validation data.201       * 202       * This should be invoked exactly once per block. It will panic at the finalization203       * phase if the call was not invoked.204       * 205       * The dispatch origin for this call must be `Inherent`206       * 207       * As a side effect, this function upgrades the current validation function208       * if the appropriate time has come.209       **/210      setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;211      sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;212      /**213       * Generic tx214       **/215      [key: string]: SubmittableExtrinsicFunction<ApiType>;216    };217    polkadotXcm: {218      /**219       * Execute an XCM message from a local, signed, origin.220       * 221       * An event is deposited indicating whether `msg` could be executed completely or only222       * partially.223       * 224       * No more than `max_weight` will be used in its attempted execution. If this is less than the225       * maximum amount of weight that the message could take to be executed, then no execution226       * attempt will be made.227       * 228       * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully229       * to completion; only that *some* of it was executed.230       **/231      execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;232      /**233       * Set a safe XCM version (the version that XCM should be encoded with if the most recent234       * version a destination can accept is unknown).235       * 236       * - `origin`: Must be Root.237       * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.238       **/239      forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;240      /**241       * Ask a location to notify us regarding their XCM version and any changes to it.242       * 243       * - `origin`: Must be Root.244       * - `location`: The location to which we should subscribe for XCM version notifications.245       **/246      forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;247      /**248       * Require that a particular destination should no longer notify us regarding any XCM249       * version changes.250       * 251       * - `origin`: Must be Root.252       * - `location`: The location to which we are currently subscribed for XCM version253       * notifications which we no longer desire.254       **/255      forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;256      /**257       * Extoll that a particular destination can be communicated with through a particular258       * version of XCM.259       * 260       * - `origin`: Must be Root.261       * - `location`: The destination that is being described.262       * - `xcm_version`: The latest version of XCM that `location` supports.263       **/264      forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;265      /**266       * Transfer some assets from the local chain to the sovereign account of a destination267       * chain and forward a notification XCM.268       * 269       * Fee payment on the destination side is made from the asset in the `assets` vector of270       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight271       * is needed than `weight_limit`, then the operation will fail and the assets send may be272       * at risk.273       * 274       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.275       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send276       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.277       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be278       * an `AccountId32` value.279       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the280       * `dest` side.281       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay282       * fees.283       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.284       **/285      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]>;286      /**287       * Teleport some assets from the local chain to some destination chain.288       * 289       * Fee payment on the destination side is made from the asset in the `assets` vector of290       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight291       * is needed than `weight_limit`, then the operation will fail and the assets send may be292       * at risk.293       * 294       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.295       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send296       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.297       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be298       * an `AccountId32` value.299       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the300       * `dest` side. May not be empty.301       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay302       * fees.303       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.304       **/305      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]>;306      /**307       * Transfer some assets from the local chain to the sovereign account of a destination308       * chain and forward a notification XCM.309       * 310       * Fee payment on the destination side is made from the asset in the `assets` vector of311       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,312       * with all fees taken as needed from the asset.313       * 314       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.315       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send316       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.317       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be318       * an `AccountId32` value.319       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the320       * `dest` side.321       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay322       * fees.323       **/324      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]>;325      send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;326      /**327       * Teleport some assets from the local chain to some destination chain.328       * 329       * Fee payment on the destination side is made from the asset in the `assets` vector of330       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,331       * with all fees taken as needed from the asset.332       * 333       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.334       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send335       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.336       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be337       * an `AccountId32` value.338       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the339       * `dest` side. May not be empty.340       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay341       * fees.342       **/343      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]>;344      /**345       * Generic tx346       **/347      [key: string]: SubmittableExtrinsicFunction<ApiType>;348    };349    rmrkCore: {350      /**351       * Accept an NFT sent from another account to self or an owned NFT.352       * 353       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.354       * 355       * # Permissions:356       * - Token-owner-to-be357       * 358       * # Arguments:359       * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.360       * - `rmrk_nft_id`: ID of the NFT to be accepted.361       * - `new_owner`: Either the sender's account ID or a sender-owned NFT,362       * whichever the accepted NFT was sent to.363       **/364      acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;365      /**366       * Accept the addition of a newly created pending resource to an existing NFT.367       * 368       * This transaction is needed when a resource is created and assigned to an NFT369       * by a non-owner, i.e. the collection issuer, with one of the370       * [`add_...` transactions](Pallet::add_basic_resource).371       * 372       * # Permissions:373       * - Token owner374       * 375       * # Arguments:376       * - `rmrk_collection_id`: RMRK collection ID of the NFT.377       * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.378       * - `resource_id`: ID of the newly created pending resource.379       **/380      acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;381      /**382       * Accept the removal of a removal-pending resource from an NFT.383       * 384       * This transaction is needed when a non-owner, i.e. the collection issuer,385       * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.386       * 387       * # Permissions:388       * - Token owner389       * 390       * # Arguments:391       * - `rmrk_collection_id`: RMRK collection ID of the NFT.392       * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.393       * - `resource_id`: ID of the removal-pending resource.394       **/395      acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;396      /**397       * Create and set/propose a basic resource for an NFT.398       * 399       * A basic resource is the simplest, lacking a Base and anything that comes with it.400       * See RMRK docs for more information and examples.401       * 402       * # Permissions:403       * - Collection issuer - if not the token owner, adding the resource will warrant404       * the owner's [acceptance](Pallet::accept_resource).405       * 406       * # Arguments:407       * - `rmrk_collection_id`: RMRK collection ID of the NFT.408       * - `nft_id`: ID of the NFT to assign a resource to.409       * - `resource`: Data of the resource to be created.410       **/411      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]>;412      /**413       * Create and set/propose a composable resource for an NFT.414       * 415       * A composable resource links to a Base and has a subset of its Parts it is composed of.416       * See RMRK docs for more information and examples.417       * 418       * # Permissions:419       * - Collection issuer - if not the token owner, adding the resource will warrant420       * the owner's [acceptance](Pallet::accept_resource).421       * 422       * # Arguments:423       * - `rmrk_collection_id`: RMRK collection ID of the NFT.424       * - `nft_id`: ID of the NFT to assign a resource to.425       * - `resource`: Data of the resource to be created.426       **/427      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]>;428      /**429       * Create and set/propose a slot resource for an NFT.430       * 431       * A slot resource links to a Base and a slot ID in it which it can fit into.432       * See RMRK docs for more information and examples.433       * 434       * # Permissions:435       * - Collection issuer - if not the token owner, adding the resource will warrant436       * the owner's [acceptance](Pallet::accept_resource).437       * 438       * # Arguments:439       * - `rmrk_collection_id`: RMRK collection ID of the NFT.440       * - `nft_id`: ID of the NFT to assign a resource to.441       * - `resource`: Data of the resource to be created.442       **/443      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]>;444      /**445       * Burn an NFT, destroying it and its nested tokens up to the specified limit.446       * If the burning budget is exceeded, the transaction is reverted.447       * 448       * This is the way to burn a nested token as well.449       * 450       * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).451       * 452       * # Permissions:453       * * Token owner454       * 455       * # Arguments:456       * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.457       * - `nft_id`: ID of the NFT to be destroyed.458       * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction459       * is reverted if there are more tokens to burn in the nesting tree than this number.460       * This is primarily a mechanism of transaction weight control.461       **/462      burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;463      /**464       * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).465       * 466       * # Permissions:467       * * Collection issuer468       * 469       * # Arguments:470       * - `collection_id`: RMRK collection ID to change the issuer of.471       * - `new_issuer`: Collection's new issuer.472       **/473      changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;474      /**475       * Create a new collection of NFTs.476       * 477       * # Permissions:478       * * Anyone - will be assigned as the issuer of the collection.479       * 480       * # Arguments:481       * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.482       * - `max`: Optional maximum number of tokens.483       * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.484       * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.485       **/486      createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | object | string | Uint8Array, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;487      /**488       * Destroy a collection.489       * 490       * Only empty collections can be destroyed. If it has any tokens, they must be burned first.491       * 492       * # Permissions:493       * * Collection issuer494       * 495       * # Arguments:496       * - `collection_id`: RMRK ID of the collection to destroy.497       **/498      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;499      /**500       * "Lock" the collection and prevent new token creation. Cannot be undone.501       * 502       * # Permissions:503       * * Collection issuer504       * 505       * # Arguments:506       * - `collection_id`: RMRK ID of the collection to lock.507       **/508      lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;509      /**510       * Mint an NFT in a specified collection.511       * 512       * # Permissions:513       * * Collection issuer514       * 515       * # Arguments:516       * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).517       * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.518       * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.519       * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.520       * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.521       * - `transferable`: Can this NFT be transferred? Cannot be changed.522       * - `resources`: Resource data to be added to the NFT immediately after minting.523       **/524      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>>]>;525      /**526       * Reject an NFT sent from another account to self or owned NFT.527       * The NFT in question will not be sent back and burnt instead.528       * 529       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.530       * 531       * # Permissions:532       * - Token-owner-to-be-not533       * 534       * # Arguments:535       * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.536       * - `rmrk_nft_id`: ID of the NFT to be rejected.537       **/538      rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;539      /**540       * Remove and erase a resource from an NFT.541       * 542       * If the sender does not own the NFT, then it will be pending confirmation,543       * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.544       * 545       * # Permissions546       * - Collection issuer547       * 548       * # Arguments549       * - `collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.550       * - `nft_id`: ID of the NFT with a resource to be removed.551       * - `resource_id`: ID of the resource to be removed.552       **/553      removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;554      /**555       * Transfer an NFT from an account/NFT A to another account/NFT B.556       * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].557       * 558       * If the target owner is an NFT owned by another account, then the NFT will enter559       * the pending state and will have to be accepted by the other account.560       * 561       * # Permissions:562       * - Token owner563       * 564       * # Arguments:565       * - `collection_id`: RMRK ID of the collection of the NFT to be transferred.566       * - `nft_id`: ID of the NFT to be transferred.567       * - `new_owner`: New owner of the nft which can be either an account or a NFT.568       **/569      send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;570      /**571       * Set a different order of resource priorities for an NFT. Priorities can be used,572       * for example, for order of rendering.573       * 574       * Note that the priorities are not updated automatically, and are an empty vector575       * by default. There is no pre-set definition for the order to be particular,576       * it can be interpreted arbitrarily use-case by use-case.577       * 578       * # Permissions:579       * - Token owner580       * 581       * # Arguments:582       * - `rmrk_collection_id`: RMRK collection ID of the NFT.583       * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.584       * - `priorities`: Ordered vector of resource IDs.585       **/586      setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;587      /**588       * Add or edit a custom user property, a key-value pair, describing the metadata589       * of a token or a collection, on either one of these.590       * 591       * Note that in this proxy implementation many details regarding RMRK are stored592       * as scoped properties prefixed with "rmrk:", normally inaccessible593       * to external transactions and RPCs.594       * 595       * # Permissions:596       * - Collection issuer - in case of collection property597       * - Token owner - in case of NFT property598       * 599       * # Arguments:600       * - `rmrk_collection_id`: RMRK collection ID.601       * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.602       * - `key`: Key of the custom property to be referenced by.603       * - `value`: Value of the custom property to be stored.604       **/605      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]>;606      /**607       * Generic tx608       **/609      [key: string]: SubmittableExtrinsicFunction<ApiType>;610    };611    rmrkEquip: {612      /**613       * Create a new Base.614       * 615       * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)616       * 617       * # Permissions618       * - Anyone - will be assigned as the issuer of the Base.619       * 620       * # Arguments:621       * - `base_type`: Arbitrary media type, e.g. "svg".622       * - `symbol`: Arbitrary client-chosen symbol.623       * - `parts`: Array of Fixed and Slot Parts composing the Base,624       * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).625       **/626      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>]>;627      /**628       * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.629       * 630       * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).631       * 632       * # Permissions:633       * - Base issuer634       * 635       * # Arguments:636       * - `base_id`: Base containing the Slot Part to be updated.637       * - `part_id`: Slot Part whose Equippable List is being updated.638       * - `equippables`: List of equippables that will override the current Equippables list.639       **/640      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]>;641      /**642       * Add a Theme to a Base.643       * A Theme named "default" is required prior to adding other Themes.644       * 645       * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).646       * 647       * # Permissions:648       * - Base issuer649       * 650       * # Arguments:651       * - `base_id`: Base ID containing the Theme to be updated.652       * - `theme`: Theme to add to the Base.  A Theme has a name and properties, which are an653       * array of [key, value, inherit].654       * - `key`: Arbitrary BoundedString, defined by client.655       * - `value`: Arbitrary BoundedString, defined by client.656       * - `inherit`: Optional bool.657       **/658      themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;659      /**660       * Generic tx661       **/662      [key: string]: SubmittableExtrinsicFunction<ApiType>;663    };664    scheduler: {665      /**666       * Cancel a named scheduled task.667       **/668      cancelNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed]>;669      /**670       * Schedule a named task.671       **/672      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]>;673      /**674       * Schedule a named task after a delay.675       * 676       * # <weight>677       * Same as [`schedule_named`](Self::schedule_named).678       * # </weight>679       **/680      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]>;681      /**682       * Generic tx683       **/684      [key: string]: SubmittableExtrinsicFunction<ApiType>;685    };686    structure: {687      /**688       * Generic tx689       **/690      [key: string]: SubmittableExtrinsicFunction<ApiType>;691    };692    sudo: {693      /**694       * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo695       * key.696       * 697       * The dispatch origin for this call must be _Signed_.698       * 699       * # <weight>700       * - O(1).701       * - Limited storage reads.702       * - One DB change.703       * # </weight>704       **/705      setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;706      /**707       * Authenticates the sudo key and dispatches a function call with `Root` origin.708       * 709       * The dispatch origin for this call must be _Signed_.710       * 711       * # <weight>712       * - O(1).713       * - Limited storage reads.714       * - One DB write (event).715       * - Weight of derivative `call` execution + 10,000.716       * # </weight>717       **/718      sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;719      /**720       * Authenticates the sudo key and dispatches a function call with `Signed` origin from721       * a given account.722       * 723       * The dispatch origin for this call must be _Signed_.724       * 725       * # <weight>726       * - O(1).727       * - Limited storage reads.728       * - One DB write (event).729       * - Weight of derivative `call` execution + 10,000.730       * # </weight>731       **/732      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]>;733      /**734       * Authenticates the sudo key and dispatches a function call with `Root` origin.735       * This function does not check the weight of the call, and instead allows the736       * Sudo user to specify the weight of the call.737       * 738       * The dispatch origin for this call must be _Signed_.739       * 740       * # <weight>741       * - O(1).742       * - The weight of this call is defined by the caller.743       * # </weight>744       **/745      sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, u64]>;746      /**747       * Generic tx748       **/749      [key: string]: SubmittableExtrinsicFunction<ApiType>;750    };751    system: {752      /**753       * A dispatch that will fill the block weight up to the given ratio.754       **/755      fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;756      /**757       * Kill all storage items with a key that starts with the given prefix.758       * 759       * **NOTE:** We rely on the Root origin to provide us the number of subkeys under760       * the prefix we are removing to accurately calculate the weight of this function.761       **/762      killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;763      /**764       * Kill some items from storage.765       **/766      killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;767      /**768       * Make some on-chain remark.769       * 770       * # <weight>771       * - `O(1)`772       * # </weight>773       **/774      remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;775      /**776       * Make some on-chain remark and emit event.777       **/778      remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;779      /**780       * Set the new runtime code.781       * 782       * # <weight>783       * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`784       * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is785       * expensive).786       * - 1 storage write (codec `O(C)`).787       * - 1 digest item.788       * - 1 event.789       * The weight of this function is dependent on the runtime, but generally this is very790       * expensive. We will treat this as a full block.791       * # </weight>792       **/793      setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;794      /**795       * Set the new runtime code without doing any checks of the given `code`.796       * 797       * # <weight>798       * - `O(C)` where `C` length of `code`799       * - 1 storage write (codec `O(C)`).800       * - 1 digest item.801       * - 1 event.802       * The weight of this function is dependent on the runtime. We will treat this as a full803       * block. # </weight>804       **/805      setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;806      /**807       * Set the number of pages in the WebAssembly environment's heap.808       **/809      setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;810      /**811       * Set some items of storage.812       **/813      setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;814      /**815       * Generic tx816       **/817      [key: string]: SubmittableExtrinsicFunction<ApiType>;818    };819    timestamp: {820      /**821       * Set the current time.822       * 823       * This call should be invoked exactly once per block. It will panic at the finalization824       * phase, if this call hasn't been invoked by that time.825       * 826       * The timestamp should be greater than the previous one by the amount specified by827       * `MinimumPeriod`.828       * 829       * The dispatch origin for this call must be `Inherent`.830       * 831       * # <weight>832       * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)833       * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in834       * `on_finalize`)835       * - 1 event handler `on_timestamp_set`. Must be `O(1)`.836       * # </weight>837       **/838      set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;839      /**840       * Generic tx841       **/842      [key: string]: SubmittableExtrinsicFunction<ApiType>;843    };844    treasury: {845      /**846       * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary847       * and the original deposit will be returned.848       * 849       * May only be called from `T::ApproveOrigin`.850       * 851       * # <weight>852       * - Complexity: O(1).853       * - DbReads: `Proposals`, `Approvals`854       * - DbWrite: `Approvals`855       * # </weight>856       **/857      approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;858      /**859       * Put forward a suggestion for spending. A deposit proportional to the value860       * is reserved and slashed if the proposal is rejected. It is returned once the861       * proposal is awarded.862       * 863       * # <weight>864       * - Complexity: O(1)865       * - DbReads: `ProposalCount`, `origin account`866       * - DbWrites: `ProposalCount`, `Proposals`, `origin account`867       * # </weight>868       **/869      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]>;870      /**871       * Reject a proposed spend. The original deposit will be slashed.872       * 873       * May only be called from `T::RejectOrigin`.874       * 875       * # <weight>876       * - Complexity: O(1)877       * - DbReads: `Proposals`, `rejected proposer account`878       * - DbWrites: `Proposals`, `rejected proposer account`879       * # </weight>880       **/881      rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;882      /**883       * Force a previously approved proposal to be removed from the approval queue.884       * The original deposit will no longer be returned.885       * 886       * May only be called from `T::RejectOrigin`.887       * - `proposal_id`: The index of a proposal888       * 889       * # <weight>890       * - Complexity: O(A) where `A` is the number of approvals891       * - Db reads and writes: `Approvals`892       * # </weight>893       * 894       * Errors:895       * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,896       * i.e., the proposal has not been approved. This could also mean the proposal does not897       * exist altogether, thus there is no way it would have been approved in the first place.898       **/899      removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;900      /**901       * Generic tx902       **/903      [key: string]: SubmittableExtrinsicFunction<ApiType>;904    };905    unique: {906      /**907       * Add an admin to a collection.908       * 909       * NFT Collection can be controlled by multiple admin addresses910       * (some which can also be servers, for example). Admins can issue911       * and burn NFTs, as well as add and remove other admins,912       * but cannot change NFT or Collection ownership.913       * 914       * # Permissions915       * 916       * * Collection owner917       * * Collection admin918       * 919       * # Arguments920       * 921       * * `collection_id`: ID of the Collection to add an admin for.922       * * `new_admin`: Address of new admin to add.923       **/924      addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdmin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;925      /**926       * Add an address to allow list.927       * 928       * # Permissions929       * 930       * * Collection owner931       * * Collection admin932       * 933       * # Arguments934       * 935       * * `collection_id`: ID of the modified collection.936       * * `address`: ID of the address to be added to the allowlist.937       **/938      addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;939      /**940       * Allow a non-permissioned address to transfer or burn an item.941       * 942       * # Permissions943       * 944       * * Collection owner945       * * Collection admin946       * * Current item owner947       * 948       * # Arguments949       * 950       * * `spender`: Account to be approved to make specific transactions on non-owned tokens.951       * * `collection_id`: ID of the collection the item belongs to.952       * * `item_id`: ID of the item transactions on which are now approved.953       * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).954       * Set to 0 to revoke the approval.955       **/956      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]>;957      /**958       * Destroy a token on behalf of the owner as a non-owner account.959       * 960       * See also: [`approve`][`Pallet::approve`].961       * 962       * After this method executes, one approval is removed from the total so that963       * the approved address will not be able to transfer this item again from this owner.964       * 965       * # Permissions966       * 967       * * Collection owner968       * * Collection admin969       * * Current token owner970       * * Address approved by current item owner971       * 972       * # Arguments973       * 974       * * `from`: The owner of the burning item.975       * * `collection_id`: ID of the collection to which the item belongs.976       * * `item_id`: ID of item to burn.977       * * `value`: Number of pieces to burn.978       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.979       * * Fungible Mode: The desired number of pieces to burn.980       * * Re-Fungible Mode: The desired number of pieces to burn.981       **/982      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]>;983      /**984       * Destroy an item.985       * 986       * # Permissions987       * 988       * * Collection owner989       * * Collection admin990       * * Current item owner991       * 992       * # Arguments993       * 994       * * `collection_id`: ID of the collection to which the item belongs.995       * * `item_id`: ID of item to burn.996       * * `value`: Number of pieces of the item to destroy.997       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.998       * * Fungible Mode: The desired number of pieces to burn.999       * * Re-Fungible Mode: The desired number of pieces to burn.1000       **/1001      burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1002      /**1003       * Change the owner of the collection.1004       * 1005       * # Permissions1006       * 1007       * * Collection owner1008       * 1009       * # Arguments1010       * 1011       * * `collection_id`: ID of the modified collection.1012       * * `new_owner`: ID of the account that will become the owner.1013       **/1014      changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1015      /**1016       * Confirm own sponsorship of a collection, becoming the sponsor.1017       * 1018       * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1019       * Sponsor can pay the fees of a transaction instead of the sender,1020       * but only within specified limits.1021       * 1022       * # Permissions1023       * 1024       * * Sponsor-to-be1025       * 1026       * # Arguments1027       * 1028       * * `collection_id`: ID of the collection with the pending sponsor.1029       **/1030      confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1031      /**1032       * Create a collection of tokens.1033       * 1034       * Each Token may have multiple properties encoded as an array of bytes1035       * of certain length. The initial owner of the collection is set1036       * to the address that signed the transaction and can be changed later.1037       * 1038       * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1039       * 1040       * # Permissions1041       * 1042       * * Anyone - becomes the owner of the new collection.1043       * 1044       * # Arguments1045       * 1046       * * `collection_name`: Wide-character string with collection name1047       * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1048       * * `collection_description`: Wide-character string with collection description1049       * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1050       * * `token_prefix`: Byte string containing the token prefix to mark a collection1051       * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1052       * * `mode`: Type of items stored in the collection and type dependent data.1053       **/1054      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]>;1055      /**1056       * Create a collection with explicit parameters.1057       * 1058       * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1059       * 1060       * # Permissions1061       * 1062       * * Anyone - becomes the owner of the new collection.1063       * 1064       * # Arguments1065       * 1066       * * `data`: Explicit data of a collection used for its creation.1067       **/1068      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]>;1069      /**1070       * Mint an item within a collection.1071       * 1072       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1073       * 1074       * # Permissions1075       * 1076       * * Collection owner1077       * * Collection admin1078       * * Anyone if1079       * * Allow List is enabled, and1080       * * Address is added to allow list, and1081       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1082       * 1083       * # Arguments1084       * 1085       * * `collection_id`: ID of the collection to which an item would belong.1086       * * `owner`: Address of the initial owner of the item.1087       * * `data`: Token data describing the item to store on chain.1088       **/1089      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]>;1090      /**1091       * Create multiple items within a collection.1092       * 1093       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1094       * 1095       * # Permissions1096       * 1097       * * Collection owner1098       * * Collection admin1099       * * Anyone if1100       * * Allow List is enabled, and1101       * * Address is added to the allow list, and1102       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1103       * 1104       * # Arguments1105       * 1106       * * `collection_id`: ID of the collection to which the tokens would belong.1107       * * `owner`: Address of the initial owner of the tokens.1108       * * `items_data`: Vector of data describing each item to be created.1109       **/1110      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>]>;1111      /**1112       * Create multiple items within a collection with explicitly specified initial parameters.1113       * 1114       * # Permissions1115       * 1116       * * Collection owner1117       * * Collection admin1118       * * Anyone if1119       * * Allow List is enabled, and1120       * * Address is added to allow list, and1121       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1122       * 1123       * # Arguments1124       * 1125       * * `collection_id`: ID of the collection to which the tokens would belong.1126       * * `data`: Explicit item creation data.1127       **/1128      createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1129      /**1130       * Delete specified collection properties.1131       * 1132       * # Permissions1133       * 1134       * * Collection Owner1135       * * Collection Admin1136       * 1137       * # Arguments1138       * 1139       * * `collection_id`: ID of the modified collection.1140       * * `property_keys`: Vector of keys of the properties to be deleted.1141       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1142       **/1143      deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1144      /**1145       * Delete specified token properties. Currently properties only work with NFTs.1146       * 1147       * # Permissions1148       * 1149       * * Depends on collection's token property permissions and specified property mutability:1150       * * Collection owner1151       * * Collection admin1152       * * Token owner1153       * 1154       * # Arguments1155       * 1156       * * `collection_id`: ID of the collection to which the token belongs.1157       * * `token_id`: ID of the modified token.1158       * * `property_keys`: Vector of keys of the properties to be deleted.1159       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1160       **/1161      deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1162      /**1163       * Destroy a collection if no tokens exist within.1164       * 1165       * # Permissions1166       * 1167       * * Collection owner1168       * 1169       * # Arguments1170       * 1171       * * `collection_id`: Collection to destroy.1172       **/1173      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1174      /**1175       * Remove admin of a collection.1176       * 1177       * An admin address can remove itself. List of admins may become empty,1178       * in which case only Collection Owner will be able to add an Admin.1179       * 1180       * # Permissions1181       * 1182       * * Collection owner1183       * * Collection admin1184       * 1185       * # Arguments1186       * 1187       * * `collection_id`: ID of the collection to remove the admin for.1188       * * `account_id`: Address of the admin to remove.1189       **/1190      removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1191      /**1192       * Remove a collection's a sponsor, making everyone pay for their own transactions.1193       * 1194       * # Permissions1195       * 1196       * * Collection owner1197       * 1198       * # Arguments1199       * 1200       * * `collection_id`: ID of the collection with the sponsor to remove.1201       **/1202      removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1203      /**1204       * Remove an address from allow list.1205       * 1206       * # Permissions1207       * 1208       * * Collection owner1209       * * Collection admin1210       * 1211       * # Arguments1212       * 1213       * * `collection_id`: ID of the modified collection.1214       * * `address`: ID of the address to be removed from the allowlist.1215       **/1216      removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1217      /**1218       * Re-partition a refungible token, while owning all of its parts/pieces.1219       * 1220       * # Permissions1221       * 1222       * * Token owner (must own every part)1223       * 1224       * # Arguments1225       * 1226       * * `collection_id`: ID of the collection the RFT belongs to.1227       * * `token_id`: ID of the RFT.1228       * * `amount`: New number of parts/pieces into which the token shall be partitioned.1229       **/1230      repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1231      /**1232       * Set specific limits of a collection. Empty, or None fields mean chain default.1233       * 1234       * # Permissions1235       * 1236       * * Collection owner1237       * * Collection admin1238       * 1239       * # Arguments1240       * 1241       * * `collection_id`: ID of the modified collection.1242       * * `new_limit`: New limits of the collection. Fields that are not set (None)1243       * will not overwrite the old ones.1244       **/1245      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]>;1246      /**1247       * Set specific permissions of a collection. Empty, or None fields mean chain default.1248       * 1249       * # Permissions1250       * 1251       * * Collection owner1252       * * Collection admin1253       * 1254       * # Arguments1255       * 1256       * * `collection_id`: ID of the modified collection.1257       * * `new_permission`: New permissions of the collection. Fields that are not set (None)1258       * will not overwrite the old ones.1259       **/1260      setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1261      /**1262       * Add or change collection properties.1263       * 1264       * # Permissions1265       * 1266       * * Collection owner1267       * * Collection admin1268       * 1269       * # Arguments1270       * 1271       * * `collection_id`: ID of the modified collection.1272       * * `properties`: Vector of key-value pairs stored as the collection's metadata.1273       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1274       **/1275      setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1276      /**1277       * Set (invite) a new collection sponsor.1278       * 1279       * If successful, confirmation from the sponsor-to-be will be pending.1280       * 1281       * # Permissions1282       * 1283       * * Collection owner1284       * * Collection admin1285       * 1286       * # Arguments1287       * 1288       * * `collection_id`: ID of the modified collection.1289       * * `new_sponsor`: ID of the account of the sponsor-to-be.1290       **/1291      setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1292      /**1293       * Add or change token properties according to collection's permissions.1294       * Currently properties only work with NFTs.1295       * 1296       * # Permissions1297       * 1298       * * Depends on collection's token property permissions and specified property mutability:1299       * * Collection owner1300       * * Collection admin1301       * * Token owner1302       * 1303       * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1304       * 1305       * # Arguments1306       * 1307       * * `collection_id: ID of the collection to which the token belongs.1308       * * `token_id`: ID of the modified token.1309       * * `properties`: Vector of key-value pairs stored as the token's metadata.1310       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1311       **/1312      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>]>;1313      /**1314       * Add or change token property permissions of a collection.1315       * 1316       * Without a permission for a particular key, a property with that key1317       * cannot be created in a token.1318       * 1319       * # Permissions1320       * 1321       * * Collection owner1322       * * Collection admin1323       * 1324       * # Arguments1325       * 1326       * * `collection_id`: ID of the modified collection.1327       * * `property_permissions`: Vector of permissions for property keys.1328       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1329       **/1330      setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1331      /**1332       * Completely allow or disallow transfers for a particular collection.1333       * 1334       * # Permissions1335       * 1336       * * Collection owner1337       * 1338       * # Arguments1339       * 1340       * * `collection_id`: ID of the collection.1341       * * `value`: New value of the flag, are transfers allowed?1342       **/1343      setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1344      /**1345       * Change ownership of the token.1346       * 1347       * # Permissions1348       * 1349       * * Collection owner1350       * * Collection admin1351       * * Current token owner1352       * 1353       * # Arguments1354       * 1355       * * `recipient`: Address of token recipient.1356       * * `collection_id`: ID of the collection the item belongs to.1357       * * `item_id`: ID of the item.1358       * * Non-Fungible Mode: Required.1359       * * Fungible Mode: Ignored.1360       * * Re-Fungible Mode: Required.1361       * 1362       * * `value`: Amount to transfer.1363       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1364       * * Fungible Mode: The desired number of pieces to transfer.1365       * * Re-Fungible Mode: The desired number of pieces to transfer.1366       **/1367      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]>;1368      /**1369       * Change ownership of an item on behalf of the owner as a non-owner account.1370       * 1371       * See the [`approve`][`Pallet::approve`] method for additional information.1372       * 1373       * After this method executes, one approval is removed from the total so that1374       * the approved address will not be able to transfer this item again from this owner.1375       * 1376       * # Permissions1377       * 1378       * * Collection owner1379       * * Collection admin1380       * * Current item owner1381       * * Address approved by current item owner1382       * 1383       * # Arguments1384       * 1385       * * `from`: Address that currently owns the token.1386       * * `recipient`: Address of the new token-owner-to-be.1387       * * `collection_id`: ID of the collection the item.1388       * * `item_id`: ID of the item to be transferred.1389       * * `value`: Amount to transfer.1390       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1391       * * Fungible Mode: The desired number of pieces to transfer.1392       * * Re-Fungible Mode: The desired number of pieces to transfer.1393       **/1394      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]>;1395      /**1396       * Generic tx1397       **/1398      [key: string]: SubmittableExtrinsicFunction<ApiType>;1399    };1400    vesting: {1401      claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1402      claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1403      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>]>;1404      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]>;1405      /**1406       * Generic tx1407       **/1408      [key: string]: SubmittableExtrinsicFunction<ApiType>;1409    };1410    xcmpQueue: {1411      /**1412       * Resumes all XCM executions for the XCMP queue.1413       * 1414       * Note that this function doesn't change the status of the in/out bound channels.1415       * 1416       * - `origin`: Must pass `ControllerOrigin`.1417       **/1418      resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1419      /**1420       * Services a single overweight XCM.1421       * 1422       * - `origin`: Must pass `ExecuteOverweightOrigin`.1423       * - `index`: The index of the overweight XCM to service1424       * - `weight_limit`: The amount of weight that XCM execution may take.1425       * 1426       * Errors:1427       * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1428       * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1429       * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1430       * 1431       * Events:1432       * - `OverweightServiced`: On success.1433       **/1434      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1435      /**1436       * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1437       * 1438       * - `origin`: Must pass `ControllerOrigin`.1439       **/1440      suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1441      /**1442       * Overwrites the number of pages of messages which must be in the queue after which we drop any further1443       * messages from the channel.1444       * 1445       * - `origin`: Must pass `Root`.1446       * - `new`: Desired value for `QueueConfigData.drop_threshold`1447       **/1448      updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1449      /**1450       * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1451       * message sending may recommence after it has been suspended.1452       * 1453       * - `origin`: Must pass `Root`.1454       * - `new`: Desired value for `QueueConfigData.resume_threshold`1455       **/1456      updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1457      /**1458       * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1459       * suspend their sending.1460       * 1461       * - `origin`: Must pass `Root`.1462       * - `new`: Desired value for `QueueConfigData.suspend_value`1463       **/1464      updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1465      /**1466       * Overwrites the amount of remaining weight under which we stop processing messages.1467       * 1468       * - `origin`: Must pass `Root`.1469       * - `new`: Desired value for `QueueConfigData.threshold_weight`1470       **/1471      updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1472      /**1473       * Overwrites the speed to which the available weight approaches the maximum weight.1474       * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1475       * 1476       * - `origin`: Must pass `Root`.1477       * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1478       **/1479      updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1480      /**1481       * Overwrite the maximum amount of weight any individual message may consume.1482       * Messages above this weight go into the overweight queue and may only be serviced explicitly.1483       * 1484       * - `origin`: Must pass `Root`.1485       * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1486       **/1487      updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1488      /**1489       * Generic tx1490       **/1491      [key: string]: SubmittableExtrinsicFunction<ApiType>;1492    };1493  } // AugmentedSubmittables1494} // declare module