git.delta.rocks / unique-network / refs/commits / e6208f5ea6c7

1// Auto-generated via `yarn polkadot-types-from-chain`, do not edit2/* eslint-disable */34// import type lookup before we augment - in some environments5// this is required to allow for ambient/previous definitions6import '@polkadot/api-base/types/submittable';78import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types';9import type { Bytes, Compact, Option, U256, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';10import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';11import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill, Weight } from '@polkadot/types/interfaces/runtime';12import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, FrameSupportScheduleMaybeHashed, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';1314export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;15export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;16export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;1718declare module '@polkadot/api-base/types/submittable' {19  interface AugmentedSubmittables<ApiType extends ApiTypes> {20    appPromotion: {21      /**22       * Recalculates interest for the specified number of stakers.23       * If all stakers are not recalculated, the next call of the extrinsic24       * will continue the recalculation, from those stakers for whom this25       * was not perform in last call.26       * 27       * # Permissions28       * 29       * * Pallet admin30       * 31       * # Arguments32       * 33       * * `stakers_number`: the number of stakers for which recalculation will be performed34       **/35      payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;36      /**37       * Sets an address as the the admin.38       * 39       * # Permissions40       * 41       * * Sudo42       * 43       * # Arguments44       * 45       * * `admin`: account of the new admin.46       **/47      setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;48      /**49       * Sets the pallet to be the sponsor for the collection.50       * 51       * # Permissions52       * 53       * * Pallet admin54       * 55       * # Arguments56       * 57       * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`58       **/59      sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;60      /**61       * Sets the pallet to be the sponsor for the contract.62       * 63       * # Permissions64       * 65       * * Pallet admin66       * 67       * # Arguments68       * 69       * * `contract_id`: the contract address that will be sponsored by `pallet_id`70       **/71      sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;72      /**73       * Stakes the amount of native tokens.74       * Sets `amount` to the locked state.75       * The maximum number of stakes for a staker is 10.76       * 77       * # Arguments78       * 79       * * `amount`: in native tokens.80       **/81      stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;82      /**83       * Removes the pallet as the sponsor for the collection.84       * Returns [`NoPermission`][`Error::NoPermission`]85       * if the pallet wasn't the sponsor.86       * 87       * # Permissions88       * 89       * * Pallet admin90       * 91       * # Arguments92       * 93       * * `collection_id`: ID of the collection that is sponsored by `pallet_id`94       **/95      stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;96      /**97       * Removes the pallet as the sponsor for the contract.98       * Returns [`NoPermission`][`Error::NoPermission`]99       * if the pallet wasn't the sponsor.100       * 101       * # Permissions102       * 103       * * Pallet admin104       * 105       * # Arguments106       * 107       * * `contract_id`: the contract address that is sponsored by `pallet_id`108       **/109      stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;110      /**111       * Unstakes all stakes.112       * Moves the sum of all stakes to the `reserved` state.113       * After the end of `PendingInterval` this sum becomes completely114       * free for further use.115       **/116      unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;117      /**118       * Generic tx119       **/120      [key: string]: SubmittableExtrinsicFunction<ApiType>;121    };122    balances: {123      /**124       * Exactly as `transfer`, except the origin must be root and the source account may be125       * specified.126       * # <weight>127       * - Same as transfer, but additional read and write because the source account is not128       * assumed to be in the overlay.129       * # </weight>130       **/131      forceTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, Compact<u128>]>;132      /**133       * Unreserve some balance from a user by force.134       * 135       * Can only be called by ROOT.136       **/137      forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;138      /**139       * Set the balances of a given account.140       * 141       * This will alter `FreeBalance` and `ReservedBalance` in storage. it will142       * also alter the total issuance of the system (`TotalIssuance`) appropriately.143       * If the new free or reserved balance is below the existential deposit,144       * it will reset the account nonce (`frame_system::AccountNonce`).145       * 146       * The dispatch origin for this call is `root`.147       **/148      setBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, newReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>, Compact<u128>]>;149      /**150       * Transfer some liquid free balance to another account.151       * 152       * `transfer` will set the `FreeBalance` of the sender and receiver.153       * If the sender's account is below the existential deposit as a result154       * of the transfer, the account will be reaped.155       * 156       * The dispatch origin for this call must be `Signed` by the transactor.157       * 158       * # <weight>159       * - Dependent on arguments but not critical, given proper implementations for input config160       * types. See related functions below.161       * - It contains a limited number of reads and writes internally and no complex162       * computation.163       * 164       * Related functions:165       * 166       * - `ensure_can_withdraw` is always called internally but has a bounded complexity.167       * - Transferring balances to accounts that did not exist before will cause168       * `T::OnNewAccount::on_new_account` to be called.169       * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.170       * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check171       * that the transfer will not kill the origin account.172       * ---------------------------------173       * - Origin account is already in memory, so no DB operations for them.174       * # </weight>175       **/176      transfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;177      /**178       * Transfer the entire transferable balance from the caller account.179       * 180       * NOTE: This function only attempts to transfer _transferable_ balances. This means that181       * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be182       * transferred by this function. To ensure that this function results in a killed account,183       * you might need to prepare the account by removing any reference counters, storage184       * deposits, etc...185       * 186       * The dispatch origin of this call must be Signed.187       * 188       * - `dest`: The recipient of the transfer.189       * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all190       * of the funds the account has, causing the sender account to be killed (false), or191       * transfer everything except at least the existential deposit, which will guarantee to192       * keep the sender account alive (true). # <weight>193       * - O(1). Just like transfer, but reading the user's transferable balance first.194       * #</weight>195       **/196      transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;197      /**198       * Same as the [`transfer`] call, but with a check that the transfer will not kill the199       * origin account.200       * 201       * 99% of the time you want [`transfer`] instead.202       * 203       * [`transfer`]: struct.Pallet.html#method.transfer204       **/205      transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;206      /**207       * Generic tx208       **/209      [key: string]: SubmittableExtrinsicFunction<ApiType>;210    };211    charging: {212      /**213       * Generic tx214       **/215      [key: string]: SubmittableExtrinsicFunction<ApiType>;216    };217    configuration: {218      setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;219      setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;220      /**221       * Generic tx222       **/223      [key: string]: SubmittableExtrinsicFunction<ApiType>;224    };225    cumulusXcm: {226      /**227       * Generic tx228       **/229      [key: string]: SubmittableExtrinsicFunction<ApiType>;230    };231    dmpQueue: {232      /**233       * Service a single overweight message.234       * 235       * - `origin`: Must pass `ExecuteOverweightOrigin`.236       * - `index`: The index of the overweight message to service.237       * - `weight_limit`: The amount of weight that message execution may take.238       * 239       * Errors:240       * - `Unknown`: Message of `index` is unknown.241       * - `OverLimit`: Message execution may use greater than `weight_limit`.242       * 243       * Events:244       * - `OverweightServiced`: On success.245       **/246      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, Weight]>;247      /**248       * Generic tx249       **/250      [key: string]: SubmittableExtrinsicFunction<ApiType>;251    };252    ethereum: {253      /**254       * Transact an Ethereum transaction.255       **/256      transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;257      /**258       * Generic tx259       **/260      [key: string]: SubmittableExtrinsicFunction<ApiType>;261    };262    evm: {263      /**264       * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.265       **/266      call: AugmentedSubmittable<(source: H160 | string | Uint8Array, target: H160 | string | Uint8Array, input: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, H160, Bytes, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;267      /**268       * Issue an EVM create operation. This is similar to a contract creation transaction in269       * Ethereum.270       **/271      create: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, Bytes, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;272      /**273       * Issue an EVM create2 operation.274       **/275      create2: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, salt: H256 | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, Bytes, H256, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;276      /**277       * Withdraw balance from EVM into currency/balances pallet.278       **/279      withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;280      /**281       * Generic tx282       **/283      [key: string]: SubmittableExtrinsicFunction<ApiType>;284    };285    evmMigration: {286      /**287       * Start contract migration, inserts contract stub at target address,288       * and marks account as pending, allowing to insert storage289       **/290      begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;291      /**292       * Finish contract migration, allows it to be called.293       * It is not possible to alter contract storage via [`Self::set_data`]294       * after this call.295       **/296      finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;297      /**298       * Insert items into contract storage, this method can be called299       * multiple times300       **/301      setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;302      /**303       * Generic tx304       **/305      [key: string]: SubmittableExtrinsicFunction<ApiType>;306    };307    foreignAssets: {308      registerForeignAsset: AugmentedSubmittable<(owner: AccountId32 | string | Uint8Array, location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;309      updateForeignAsset: AugmentedSubmittable<(foreignAssetId: u32 | AnyNumber | Uint8Array, location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;310      /**311       * Generic tx312       **/313      [key: string]: SubmittableExtrinsicFunction<ApiType>;314    };315    inflation: {316      /**317       * This method sets the inflation start date. Can be only called once.318       * Inflation start block can be backdated and will catch up. The method will create Treasury319       * account if it does not exist and perform the first inflation deposit.320       * 321       * # Permissions322       * 323       * * Root324       * 325       * # Arguments326       * 327       * * inflation_start_relay_block: The relay chain block at which inflation should start328       **/329      startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;330      /**331       * Generic tx332       **/333      [key: string]: SubmittableExtrinsicFunction<ApiType>;334    };335    maintenance: {336      disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;337      enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;338      /**339       * Generic tx340       **/341      [key: string]: SubmittableExtrinsicFunction<ApiType>;342    };343    parachainSystem: {344      authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;345      enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;346      /**347       * Set the current validation data.348       * 349       * This should be invoked exactly once per block. It will panic at the finalization350       * phase if the call was not invoked.351       * 352       * The dispatch origin for this call must be `Inherent`353       * 354       * As a side effect, this function upgrades the current validation function355       * if the appropriate time has come.356       **/357      setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;358      sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;359      /**360       * Generic tx361       **/362      [key: string]: SubmittableExtrinsicFunction<ApiType>;363    };364    polkadotXcm: {365      /**366       * Execute an XCM message from a local, signed, origin.367       * 368       * An event is deposited indicating whether `msg` could be executed completely or only369       * partially.370       * 371       * No more than `max_weight` will be used in its attempted execution. If this is less than the372       * maximum amount of weight that the message could take to be executed, then no execution373       * attempt will be made.374       * 375       * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully376       * to completion; only that *some* of it was executed.377       **/378      execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, Weight]>;379      /**380       * Set a safe XCM version (the version that XCM should be encoded with if the most recent381       * version a destination can accept is unknown).382       * 383       * - `origin`: Must be Root.384       * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.385       **/386      forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;387      /**388       * Ask a location to notify us regarding their XCM version and any changes to it.389       * 390       * - `origin`: Must be Root.391       * - `location`: The location to which we should subscribe for XCM version notifications.392       **/393      forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;394      /**395       * Require that a particular destination should no longer notify us regarding any XCM396       * version changes.397       * 398       * - `origin`: Must be Root.399       * - `location`: The location to which we are currently subscribed for XCM version400       * notifications which we no longer desire.401       **/402      forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;403      /**404       * Extoll that a particular destination can be communicated with through a particular405       * version of XCM.406       * 407       * - `origin`: Must be Root.408       * - `location`: The destination that is being described.409       * - `xcm_version`: The latest version of XCM that `location` supports.410       **/411      forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;412      /**413       * Transfer some assets from the local chain to the sovereign account of a destination414       * chain and forward a notification XCM.415       * 416       * Fee payment on the destination side is made from the asset in the `assets` vector of417       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight418       * is needed than `weight_limit`, then the operation will fail and the assets send may be419       * at risk.420       * 421       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.422       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send423       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.424       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be425       * an `AccountId32` value.426       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the427       * `dest` side.428       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay429       * fees.430       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.431       **/432      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]>;433      /**434       * Teleport some assets from the local chain to some destination chain.435       * 436       * Fee payment on the destination side is made from the asset in the `assets` vector of437       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight438       * is needed than `weight_limit`, then the operation will fail and the assets send may be439       * at risk.440       * 441       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.442       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send443       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.444       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be445       * an `AccountId32` value.446       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the447       * `dest` side. May not be empty.448       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay449       * fees.450       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.451       **/452      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]>;453      /**454       * Transfer some assets from the local chain to the sovereign account of a destination455       * chain and forward a notification XCM.456       * 457       * Fee payment on the destination side is made from the asset in the `assets` vector of458       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,459       * with all fees taken as needed from the asset.460       * 461       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.462       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send463       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.464       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be465       * an `AccountId32` value.466       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the467       * `dest` side.468       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay469       * fees.470       **/471      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]>;472      send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;473      /**474       * Teleport some assets from the local chain to some destination chain.475       * 476       * Fee payment on the destination side is made from the asset in the `assets` vector of477       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,478       * with all fees taken as needed from the asset.479       * 480       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.481       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send482       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.483       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be484       * an `AccountId32` value.485       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the486       * `dest` side. May not be empty.487       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay488       * fees.489       **/490      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]>;491      /**492       * Generic tx493       **/494      [key: string]: SubmittableExtrinsicFunction<ApiType>;495    };496    rmrkCore: {497      /**498       * Accept an NFT sent from another account to self or an owned NFT.499       * 500       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.501       * 502       * # Permissions:503       * - Token-owner-to-be504       * 505       * # Arguments:506       * - `origin`: sender of the transaction507       * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.508       * - `rmrk_nft_id`: ID of the NFT to be accepted.509       * - `new_owner`: Either the sender's account ID or a sender-owned NFT,510       * whichever the accepted NFT was sent to.511       **/512      acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;513      /**514       * Accept the addition of a newly created pending resource to an existing NFT.515       * 516       * This transaction is needed when a resource is created and assigned to an NFT517       * by a non-owner, i.e. the collection issuer, with one of the518       * [`add_...` transactions](Pallet::add_basic_resource).519       * 520       * # Permissions:521       * - Token owner522       * 523       * # Arguments:524       * - `origin`: sender of the transaction525       * - `rmrk_collection_id`: RMRK collection ID of the NFT.526       * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.527       * - `resource_id`: ID of the newly created pending resource.528       * accept the addition of a new resource to an existing NFT529       **/530      acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;531      /**532       * Accept the removal of a removal-pending resource from an NFT.533       * 534       * This transaction is needed when a non-owner, i.e. the collection issuer,535       * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.536       * 537       * # Permissions:538       * - Token owner539       * 540       * # Arguments:541       * - `origin`: sender of the transaction542       * - `rmrk_collection_id`: RMRK collection ID of the NFT.543       * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.544       * - `resource_id`: ID of the removal-pending resource.545       **/546      acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;547      /**548       * Create and set/propose a basic resource for an NFT.549       * 550       * A basic resource is the simplest, lacking a Base and anything that comes with it.551       * See RMRK docs for more information and examples.552       * 553       * # Permissions:554       * - Collection issuer - if not the token owner, adding the resource will warrant555       * the owner's [acceptance](Pallet::accept_resource).556       * 557       * # Arguments:558       * - `origin`: sender of the transaction559       * - `rmrk_collection_id`: RMRK collection ID of the NFT.560       * - `nft_id`: ID of the NFT to assign a resource to.561       * - `resource`: Data of the resource to be created.562       **/563      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]>;564      /**565       * Create and set/propose a composable resource for an NFT.566       * 567       * A composable resource links to a Base and has a subset of its Parts it is composed of.568       * See RMRK docs for more information and examples.569       * 570       * # Permissions:571       * - Collection issuer - if not the token owner, adding the resource will warrant572       * the owner's [acceptance](Pallet::accept_resource).573       * 574       * # Arguments:575       * - `origin`: sender of the transaction576       * - `rmrk_collection_id`: RMRK collection ID of the NFT.577       * - `nft_id`: ID of the NFT to assign a resource to.578       * - `resource`: Data of the resource to be created.579       **/580      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]>;581      /**582       * Create and set/propose a slot resource for an NFT.583       * 584       * A slot resource links to a Base and a slot ID in it which it can fit into.585       * See RMRK docs for more information and examples.586       * 587       * # Permissions:588       * - Collection issuer - if not the token owner, adding the resource will warrant589       * the owner's [acceptance](Pallet::accept_resource).590       * 591       * # Arguments:592       * - `origin`: sender of the transaction593       * - `rmrk_collection_id`: RMRK collection ID of the NFT.594       * - `nft_id`: ID of the NFT to assign a resource to.595       * - `resource`: Data of the resource to be created.596       **/597      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]>;598      /**599       * Burn an NFT, destroying it and its nested tokens up to the specified limit.600       * If the burning budget is exceeded, the transaction is reverted.601       * 602       * This is the way to burn a nested token as well.603       * 604       * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).605       * 606       * # Permissions:607       * * Token owner608       * 609       * # Arguments:610       * - `origin`: sender of the transaction611       * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.612       * - `nft_id`: ID of the NFT to be destroyed.613       * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction614       * is reverted if there are more tokens to burn in the nesting tree than this number.615       * This is primarily a mechanism of transaction weight control.616       **/617      burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;618      /**619       * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).620       * 621       * # Permissions:622       * * Collection issuer623       * 624       * # Arguments:625       * - `origin`: sender of the transaction626       * - `collection_id`: RMRK collection ID to change the issuer of.627       * - `new_issuer`: Collection's new issuer.628       **/629      changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;630      /**631       * Create a new collection of NFTs.632       * 633       * # Permissions:634       * * Anyone - will be assigned as the issuer of the collection.635       * 636       * # Arguments:637       * - `origin`: sender of the transaction638       * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.639       * - `max`: Optional maximum number of tokens.640       * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.641       * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.642       **/643      createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;644      /**645       * Destroy a collection.646       * 647       * Only empty collections can be destroyed. If it has any tokens, they must be burned first.648       * 649       * # Permissions:650       * * Collection issuer651       * 652       * # Arguments:653       * - `origin`: sender of the transaction654       * - `collection_id`: RMRK ID of the collection to destroy.655       **/656      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;657      /**658       * "Lock" the collection and prevent new token creation. Cannot be undone.659       * 660       * # Permissions:661       * * Collection issuer662       * 663       * # Arguments:664       * - `origin`: sender of the transaction665       * - `collection_id`: RMRK ID of the collection to lock.666       **/667      lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;668      /**669       * Mint an NFT in a specified collection.670       * 671       * # Permissions:672       * * Collection issuer673       * 674       * # Arguments:675       * - `origin`: sender of the transaction676       * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).677       * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.678       * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.679       * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.680       * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.681       * - `transferable`: Can this NFT be transferred? Cannot be changed.682       * - `resources`: Resource data to be added to the NFT immediately after minting.683       **/684      mintNft: AugmentedSubmittable<(owner: Option<AccountId32> | null | Uint8Array | AccountId32 | string, collectionId: u32 | AnyNumber | Uint8Array, recipient: Option<AccountId32> | null | Uint8Array | AccountId32 | string, royaltyAmount: Option<Permill> | null | Uint8Array | Permill | AnyNumber, metadata: Bytes | string | Uint8Array, transferable: bool | boolean | Uint8Array, resources: Option<Vec<RmrkTraitsResourceResourceTypes>> | null | Uint8Array | Vec<RmrkTraitsResourceResourceTypes> | (RmrkTraitsResourceResourceTypes | { Basic: any } | { Composable: any } | { Slot: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<AccountId32>, u32, Option<AccountId32>, Option<Permill>, Bytes, bool, Option<Vec<RmrkTraitsResourceResourceTypes>>]>;685      /**686       * Reject an NFT sent from another account to self or owned NFT.687       * The NFT in question will not be sent back and burnt instead.688       * 689       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.690       * 691       * # Permissions:692       * - Token-owner-to-be-not693       * 694       * # Arguments:695       * - `origin`: sender of the transaction696       * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.697       * - `rmrk_nft_id`: ID of the NFT to be rejected.698       **/699      rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;700      /**701       * Remove and erase a resource from an NFT.702       * 703       * If the sender does not own the NFT, then it will be pending confirmation,704       * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.705       * 706       * # Permissions707       * - Collection issuer708       * 709       * # Arguments710       * - `origin`: sender of the transaction711       * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.712       * - `nft_id`: ID of the NFT with a resource to be removed.713       * - `resource_id`: ID of the resource to be removed.714       **/715      removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;716      /**717       * Transfer an NFT from an account/NFT A to another account/NFT B.718       * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].719       * 720       * If the target owner is an NFT owned by another account, then the NFT will enter721       * the pending state and will have to be accepted by the other account.722       * 723       * # Permissions:724       * - Token owner725       * 726       * # Arguments:727       * - `origin`: sender of the transaction728       * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.729       * - `rmrk_nft_id`: ID of the NFT to be transferred.730       * - `new_owner`: New owner of the nft which can be either an account or a NFT.731       **/732      send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;733      /**734       * Set a different order of resource priorities for an NFT. Priorities can be used,735       * for example, for order of rendering.736       * 737       * Note that the priorities are not updated automatically, and are an empty vector738       * by default. There is no pre-set definition for the order to be particular,739       * it can be interpreted arbitrarily use-case by use-case.740       * 741       * # Permissions:742       * - Token owner743       * 744       * # Arguments:745       * - `origin`: sender of the transaction746       * - `rmrk_collection_id`: RMRK collection ID of the NFT.747       * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.748       * - `priorities`: Ordered vector of resource IDs.749       **/750      setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;751      /**752       * Add or edit a custom user property, a key-value pair, describing the metadata753       * of a token or a collection, on either one of these.754       * 755       * Note that in this proxy implementation many details regarding RMRK are stored756       * as scoped properties prefixed with "rmrk:", normally inaccessible757       * to external transactions and RPCs.758       * 759       * # Permissions:760       * - Collection issuer - in case of collection property761       * - Token owner - in case of NFT property762       * 763       * # Arguments:764       * - `origin`: sender of the transaction765       * - `rmrk_collection_id`: RMRK collection ID.766       * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.767       * - `key`: Key of the custom property to be referenced by.768       * - `value`: Value of the custom property to be stored.769       **/770      setProperty: AugmentedSubmittable<(rmrkCollectionId: Compact<u32> | AnyNumber | Uint8Array, maybeNftId: Option<u32> | null | Uint8Array | u32 | AnyNumber, key: Bytes | string | Uint8Array, value: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Option<u32>, Bytes, Bytes]>;771      /**772       * Generic tx773       **/774      [key: string]: SubmittableExtrinsicFunction<ApiType>;775    };776    rmrkEquip: {777      /**778       * Create a new Base.779       * 780       * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)781       * 782       * # Permissions783       * - Anyone - will be assigned as the issuer of the Base.784       * 785       * # Arguments:786       * - `origin`: Caller, will be assigned as the issuer of the Base787       * - `base_type`: Arbitrary media type, e.g. "svg".788       * - `symbol`: Arbitrary client-chosen symbol.789       * - `parts`: Array of Fixed and Slot Parts composing the Base,790       * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).791       **/792      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>]>;793      /**794       * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.795       * 796       * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).797       * 798       * # Permissions:799       * - Base issuer800       * 801       * # Arguments:802       * - `origin`: sender of the transaction803       * - `base_id`: Base containing the Slot Part to be updated.804       * - `slot_id`: Slot Part whose Equippable List is being updated .805       * - `equippables`: List of equippables that will override the current Equippables list.806       **/807      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]>;808      /**809       * Add a Theme to a Base.810       * A Theme named "default" is required prior to adding other Themes.811       * 812       * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).813       * 814       * # Permissions:815       * - Base issuer816       * 817       * # Arguments:818       * - `origin`: sender of the transaction819       * - `base_id`: Base ID containing the Theme to be updated.820       * - `theme`: Theme to add to the Base.  A Theme has a name and properties, which are an821       * array of [key, value, inherit].822       * - `key`: Arbitrary BoundedString, defined by client.823       * - `value`: Arbitrary BoundedString, defined by client.824       * - `inherit`: Optional bool.825       **/826      themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;827      /**828       * Generic tx829       **/830      [key: string]: SubmittableExtrinsicFunction<ApiType>;831    };832    scheduler: {833      /**834       * Cancel a named scheduled task.835       **/836      cancelNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed]>;837      changeNamedPriority: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u8]>;838      /**839       * Schedule a named task.840       **/841      scheduleNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: Option<u8> | null | Uint8Array | u8 | AnyNumber, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, Option<u8>, FrameSupportScheduleMaybeHashed]>;842      /**843       * Schedule a named task after a delay.844       * 845       * # <weight>846       * Same as [`schedule_named`](Self::schedule_named).847       * # </weight>848       **/849      scheduleNamedAfter: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: Option<u8> | null | Uint8Array | u8 | AnyNumber, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, Option<u8>, FrameSupportScheduleMaybeHashed]>;850      /**851       * Generic tx852       **/853      [key: string]: SubmittableExtrinsicFunction<ApiType>;854    };855    structure: {856      /**857       * Generic tx858       **/859      [key: string]: SubmittableExtrinsicFunction<ApiType>;860    };861    sudo: {862      /**863       * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo864       * key.865       * 866       * The dispatch origin for this call must be _Signed_.867       * 868       * # <weight>869       * - O(1).870       * - Limited storage reads.871       * - One DB change.872       * # </weight>873       **/874      setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;875      /**876       * Authenticates the sudo key and dispatches a function call with `Root` origin.877       * 878       * The dispatch origin for this call must be _Signed_.879       * 880       * # <weight>881       * - O(1).882       * - Limited storage reads.883       * - One DB write (event).884       * - Weight of derivative `call` execution + 10,000.885       * # </weight>886       **/887      sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;888      /**889       * Authenticates the sudo key and dispatches a function call with `Signed` origin from890       * a given account.891       * 892       * The dispatch origin for this call must be _Signed_.893       * 894       * # <weight>895       * - O(1).896       * - Limited storage reads.897       * - One DB write (event).898       * - Weight of derivative `call` execution + 10,000.899       * # </weight>900       **/901      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]>;902      /**903       * Authenticates the sudo key and dispatches a function call with `Root` origin.904       * This function does not check the weight of the call, and instead allows the905       * Sudo user to specify the weight of the call.906       * 907       * The dispatch origin for this call must be _Signed_.908       * 909       * # <weight>910       * - O(1).911       * - The weight of this call is defined by the caller.912       * # </weight>913       **/914      sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, Weight]>;915      /**916       * Generic tx917       **/918      [key: string]: SubmittableExtrinsicFunction<ApiType>;919    };920    system: {921      /**922       * A dispatch that will fill the block weight up to the given ratio.923       **/924      fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;925      /**926       * Kill all storage items with a key that starts with the given prefix.927       * 928       * **NOTE:** We rely on the Root origin to provide us the number of subkeys under929       * the prefix we are removing to accurately calculate the weight of this function.930       **/931      killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;932      /**933       * Kill some items from storage.934       **/935      killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;936      /**937       * Make some on-chain remark.938       * 939       * # <weight>940       * - `O(1)`941       * # </weight>942       **/943      remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;944      /**945       * Make some on-chain remark and emit event.946       **/947      remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;948      /**949       * Set the new runtime code.950       * 951       * # <weight>952       * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`953       * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is954       * expensive).955       * - 1 storage write (codec `O(C)`).956       * - 1 digest item.957       * - 1 event.958       * The weight of this function is dependent on the runtime, but generally this is very959       * expensive. We will treat this as a full block.960       * # </weight>961       **/962      setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;963      /**964       * Set the new runtime code without doing any checks of the given `code`.965       * 966       * # <weight>967       * - `O(C)` where `C` length of `code`968       * - 1 storage write (codec `O(C)`).969       * - 1 digest item.970       * - 1 event.971       * The weight of this function is dependent on the runtime. We will treat this as a full972       * block. # </weight>973       **/974      setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;975      /**976       * Set the number of pages in the WebAssembly environment's heap.977       **/978      setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;979      /**980       * Set some items of storage.981       **/982      setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;983      /**984       * Generic tx985       **/986      [key: string]: SubmittableExtrinsicFunction<ApiType>;987    };988    testUtils: {989      enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;990      incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;991      justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;992      selfCancelingInc: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, maxTestValue: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32]>;993      setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;994      setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;995      /**996       * Generic tx997       **/998      [key: string]: SubmittableExtrinsicFunction<ApiType>;999    };1000    timestamp: {1001      /**1002       * Set the current time.1003       * 1004       * This call should be invoked exactly once per block. It will panic at the finalization1005       * phase, if this call hasn't been invoked by that time.1006       * 1007       * The timestamp should be greater than the previous one by the amount specified by1008       * `MinimumPeriod`.1009       * 1010       * The dispatch origin for this call must be `Inherent`.1011       * 1012       * # <weight>1013       * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1014       * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1015       * `on_finalize`)1016       * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1017       * # </weight>1018       **/1019      set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1020      /**1021       * Generic tx1022       **/1023      [key: string]: SubmittableExtrinsicFunction<ApiType>;1024    };1025    tokens: {1026      /**1027       * Exactly as `transfer`, except the origin must be root and the source1028       * account may be specified.1029       * 1030       * The dispatch origin for this call must be _Root_.1031       * 1032       * - `source`: The sender of the transfer.1033       * - `dest`: The recipient of the transfer.1034       * - `currency_id`: currency type.1035       * - `amount`: free balance amount to tranfer.1036       **/1037      forceTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, PalletForeignAssetsAssetIds, Compact<u128>]>;1038      /**1039       * Set the balances of a given account.1040       * 1041       * This will alter `FreeBalance` and `ReservedBalance` in storage. it1042       * will also decrease the total issuance of the system1043       * (`TotalIssuance`). If the new free or reserved balance is below the1044       * existential deposit, it will reap the `AccountInfo`.1045       * 1046       * The dispatch origin for this call is `root`.1047       **/1048      setBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, newReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeignAssetsAssetIds, Compact<u128>, Compact<u128>]>;1049      /**1050       * Transfer some liquid free balance to another account.1051       * 1052       * `transfer` will set the `FreeBalance` of the sender and receiver.1053       * It will decrease the total issuance of the system by the1054       * `TransferFee`. If the sender's account is below the existential1055       * deposit as a result of the transfer, the account will be reaped.1056       * 1057       * The dispatch origin for this call must be `Signed` by the1058       * transactor.1059       * 1060       * - `dest`: The recipient of the transfer.1061       * - `currency_id`: currency type.1062       * - `amount`: free balance amount to tranfer.1063       **/1064      transfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeignAssetsAssetIds, Compact<u128>]>;1065      /**1066       * Transfer all remaining balance to the given account.1067       * 1068       * NOTE: This function only attempts to transfer _transferable_1069       * balances. This means that any locked, reserved, or existential1070       * deposits (when `keep_alive` is `true`), will not be transferred by1071       * this function. To ensure that this function results in a killed1072       * account, you might need to prepare the account by removing any1073       * reference counters, storage deposits, etc...1074       * 1075       * The dispatch origin for this call must be `Signed` by the1076       * transactor.1077       * 1078       * - `dest`: The recipient of the transfer.1079       * - `currency_id`: currency type.1080       * - `keep_alive`: A boolean to determine if the `transfer_all`1081       * operation should send all of the funds the account has, causing1082       * the sender account to be killed (false), or transfer everything1083       * except at least the existential deposit, which will guarantee to1084       * keep the sender account alive (true).1085       **/1086      transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeignAssetsAssetIds, bool]>;1087      /**1088       * Same as the [`transfer`] call, but with a check that the transfer1089       * will not kill the origin account.1090       * 1091       * 99% of the time you want [`transfer`] instead.1092       * 1093       * The dispatch origin for this call must be `Signed` by the1094       * transactor.1095       * 1096       * - `dest`: The recipient of the transfer.1097       * - `currency_id`: currency type.1098       * - `amount`: free balance amount to tranfer.1099       **/1100      transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeignAssetsAssetIds, Compact<u128>]>;1101      /**1102       * Generic tx1103       **/1104      [key: string]: SubmittableExtrinsicFunction<ApiType>;1105    };1106    treasury: {1107      /**1108       * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1109       * and the original deposit will be returned.1110       * 1111       * May only be called from `T::ApproveOrigin`.1112       * 1113       * # <weight>1114       * - Complexity: O(1).1115       * - DbReads: `Proposals`, `Approvals`1116       * - DbWrite: `Approvals`1117       * # </weight>1118       **/1119      approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1120      /**1121       * Put forward a suggestion for spending. A deposit proportional to the value1122       * is reserved and slashed if the proposal is rejected. It is returned once the1123       * proposal is awarded.1124       * 1125       * # <weight>1126       * - Complexity: O(1)1127       * - DbReads: `ProposalCount`, `origin account`1128       * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1129       * # </weight>1130       **/1131      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]>;1132      /**1133       * Reject a proposed spend. The original deposit will be slashed.1134       * 1135       * May only be called from `T::RejectOrigin`.1136       * 1137       * # <weight>1138       * - Complexity: O(1)1139       * - DbReads: `Proposals`, `rejected proposer account`1140       * - DbWrites: `Proposals`, `rejected proposer account`1141       * # </weight>1142       **/1143      rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1144      /**1145       * Force a previously approved proposal to be removed from the approval queue.1146       * The original deposit will no longer be returned.1147       * 1148       * May only be called from `T::RejectOrigin`.1149       * - `proposal_id`: The index of a proposal1150       * 1151       * # <weight>1152       * - Complexity: O(A) where `A` is the number of approvals1153       * - Db reads and writes: `Approvals`1154       * # </weight>1155       * 1156       * Errors:1157       * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1158       * i.e., the proposal has not been approved. This could also mean the proposal does not1159       * exist altogether, thus there is no way it would have been approved in the first place.1160       **/1161      removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1162      /**1163       * Propose and approve a spend of treasury funds.1164       * 1165       * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1166       * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1167       * - `beneficiary`: The destination account for the transfer.1168       * 1169       * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1170       * beneficiary.1171       **/1172      spend: AugmentedSubmittable<(amount: Compact<u128> | AnyNumber | Uint8Array, beneficiary: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>, MultiAddress]>;1173      /**1174       * Generic tx1175       **/1176      [key: string]: SubmittableExtrinsicFunction<ApiType>;1177    };1178    unique: {1179      /**1180       * Add an admin to a collection.1181       * 1182       * NFT Collection can be controlled by multiple admin addresses1183       * (some which can also be servers, for example). Admins can issue1184       * and burn NFTs, as well as add and remove other admins,1185       * but cannot change NFT or Collection ownership.1186       * 1187       * # Permissions1188       * 1189       * * Collection owner1190       * * Collection admin1191       * 1192       * # Arguments1193       * 1194       * * `collection_id`: ID of the Collection to add an admin for.1195       * * `new_admin`: Address of new admin to add.1196       **/1197      addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1198      /**1199       * Add an address to allow list.1200       * 1201       * # Permissions1202       * 1203       * * Collection owner1204       * * Collection admin1205       * 1206       * # Arguments1207       * 1208       * * `collection_id`: ID of the modified collection.1209       * * `address`: ID of the address to be added to the allowlist.1210       **/1211      addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1212      /**1213       * Allow a non-permissioned address to transfer or burn an item.1214       * 1215       * # Permissions1216       * 1217       * * Collection owner1218       * * Collection admin1219       * * Current item owner1220       * 1221       * # Arguments1222       * 1223       * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1224       * * `collection_id`: ID of the collection the item belongs to.1225       * * `item_id`: ID of the item transactions on which are now approved.1226       * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1227       * Set to 0 to revoke the approval.1228       **/1229      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]>;1230      /**1231       * Destroy a token on behalf of the owner as a non-owner account.1232       * 1233       * See also: [`approve`][`Pallet::approve`].1234       * 1235       * After this method executes, one approval is removed from the total so that1236       * the approved address will not be able to transfer this item again from this owner.1237       * 1238       * # Permissions1239       * 1240       * * Collection owner1241       * * Collection admin1242       * * Current token owner1243       * * Address approved by current item owner1244       * 1245       * # Arguments1246       * 1247       * * `from`: The owner of the burning item.1248       * * `collection_id`: ID of the collection to which the item belongs.1249       * * `item_id`: ID of item to burn.1250       * * `value`: Number of pieces to burn.1251       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1252       * * Fungible Mode: The desired number of pieces to burn.1253       * * Re-Fungible Mode: The desired number of pieces to burn.1254       **/1255      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]>;1256      /**1257       * Destroy an item.1258       * 1259       * # Permissions1260       * 1261       * * Collection owner1262       * * Collection admin1263       * * Current item owner1264       * 1265       * # Arguments1266       * 1267       * * `collection_id`: ID of the collection to which the item belongs.1268       * * `item_id`: ID of item to burn.1269       * * `value`: Number of pieces of the item to destroy.1270       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1271       * * Fungible Mode: The desired number of pieces to burn.1272       * * Re-Fungible Mode: The desired number of pieces to burn.1273       **/1274      burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1275      /**1276       * Change the owner of the collection.1277       * 1278       * # Permissions1279       * 1280       * * Collection owner1281       * 1282       * # Arguments1283       * 1284       * * `collection_id`: ID of the modified collection.1285       * * `new_owner`: ID of the account that will become the owner.1286       **/1287      changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1288      /**1289       * Confirm own sponsorship of a collection, becoming the sponsor.1290       * 1291       * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1292       * Sponsor can pay the fees of a transaction instead of the sender,1293       * but only within specified limits.1294       * 1295       * # Permissions1296       * 1297       * * Sponsor-to-be1298       * 1299       * # Arguments1300       * 1301       * * `collection_id`: ID of the collection with the pending sponsor.1302       **/1303      confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1304      /**1305       * Create a collection of tokens.1306       * 1307       * Each Token may have multiple properties encoded as an array of bytes1308       * of certain length. The initial owner of the collection is set1309       * to the address that signed the transaction and can be changed later.1310       * 1311       * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1312       * 1313       * # Permissions1314       * 1315       * * Anyone - becomes the owner of the new collection.1316       * 1317       * # Arguments1318       * 1319       * * `collection_name`: Wide-character string with collection name1320       * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1321       * * `collection_description`: Wide-character string with collection description1322       * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1323       * * `token_prefix`: Byte string containing the token prefix to mark a collection1324       * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1325       * * `mode`: Type of items stored in the collection and type dependent data.1326       **/1327      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]>;1328      /**1329       * Create a collection with explicit parameters.1330       * 1331       * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1332       * 1333       * # Permissions1334       * 1335       * * Anyone - becomes the owner of the new collection.1336       * 1337       * # Arguments1338       * 1339       * * `data`: Explicit data of a collection used for its creation.1340       **/1341      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]>;1342      /**1343       * Mint an item within a collection.1344       * 1345       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1346       * 1347       * # Permissions1348       * 1349       * * Collection owner1350       * * Collection admin1351       * * Anyone if1352       * * Allow List is enabled, and1353       * * Address is added to allow list, and1354       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1355       * 1356       * # Arguments1357       * 1358       * * `collection_id`: ID of the collection to which an item would belong.1359       * * `owner`: Address of the initial owner of the item.1360       * * `data`: Token data describing the item to store on chain.1361       **/1362      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]>;1363      /**1364       * Create multiple items within a collection.1365       * 1366       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1367       * 1368       * # Permissions1369       * 1370       * * Collection owner1371       * * Collection admin1372       * * Anyone if1373       * * Allow List is enabled, and1374       * * Address is added to the allow list, and1375       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1376       * 1377       * # Arguments1378       * 1379       * * `collection_id`: ID of the collection to which the tokens would belong.1380       * * `owner`: Address of the initial owner of the tokens.1381       * * `items_data`: Vector of data describing each item to be created.1382       **/1383      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>]>;1384      /**1385       * Create multiple items within a collection with explicitly specified initial parameters.1386       * 1387       * # Permissions1388       * 1389       * * Collection owner1390       * * Collection admin1391       * * Anyone if1392       * * Allow List is enabled, and1393       * * Address is added to allow list, and1394       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1395       * 1396       * # Arguments1397       * 1398       * * `collection_id`: ID of the collection to which the tokens would belong.1399       * * `data`: Explicit item creation data.1400       **/1401      createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1402      /**1403       * Delete specified collection properties.1404       * 1405       * # Permissions1406       * 1407       * * Collection Owner1408       * * Collection Admin1409       * 1410       * # Arguments1411       * 1412       * * `collection_id`: ID of the modified collection.1413       * * `property_keys`: Vector of keys of the properties to be deleted.1414       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1415       **/1416      deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1417      /**1418       * Delete specified token properties. Currently properties only work with NFTs.1419       * 1420       * # Permissions1421       * 1422       * * Depends on collection's token property permissions and specified property mutability:1423       * * Collection owner1424       * * Collection admin1425       * * Token owner1426       * 1427       * # Arguments1428       * 1429       * * `collection_id`: ID of the collection to which the token belongs.1430       * * `token_id`: ID of the modified token.1431       * * `property_keys`: Vector of keys of the properties to be deleted.1432       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1433       **/1434      deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1435      /**1436       * Destroy a collection if no tokens exist within.1437       * 1438       * # Permissions1439       * 1440       * * Collection owner1441       * 1442       * # Arguments1443       * 1444       * * `collection_id`: Collection to destroy.1445       **/1446      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1447      /**1448       * Remove admin of a collection.1449       * 1450       * An admin address can remove itself. List of admins may become empty,1451       * in which case only Collection Owner will be able to add an Admin.1452       * 1453       * # Permissions1454       * 1455       * * Collection owner1456       * * Collection admin1457       * 1458       * # Arguments1459       * 1460       * * `collection_id`: ID of the collection to remove the admin for.1461       * * `account_id`: Address of the admin to remove.1462       **/1463      removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1464      /**1465       * Remove a collection's a sponsor, making everyone pay for their own transactions.1466       * 1467       * # Permissions1468       * 1469       * * Collection owner1470       * 1471       * # Arguments1472       * 1473       * * `collection_id`: ID of the collection with the sponsor to remove.1474       **/1475      removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1476      /**1477       * Remove an address from allow list.1478       * 1479       * # Permissions1480       * 1481       * * Collection owner1482       * * Collection admin1483       * 1484       * # Arguments1485       * 1486       * * `collection_id`: ID of the modified collection.1487       * * `address`: ID of the address to be removed from the allowlist.1488       **/1489      removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1490      /**1491       * Re-partition a refungible token, while owning all of its parts/pieces.1492       * 1493       * # Permissions1494       * 1495       * * Token owner (must own every part)1496       * 1497       * # Arguments1498       * 1499       * * `collection_id`: ID of the collection the RFT belongs to.1500       * * `token_id`: ID of the RFT.1501       * * `amount`: New number of parts/pieces into which the token shall be partitioned.1502       **/1503      repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1504      /**1505       * Set specific limits of a collection. Empty, or None fields mean chain default.1506       * 1507       * # Permissions1508       * 1509       * * Collection owner1510       * * Collection admin1511       * 1512       * # Arguments1513       * 1514       * * `collection_id`: ID of the modified collection.1515       * * `new_limit`: New limits of the collection. Fields that are not set (None)1516       * will not overwrite the old ones.1517       **/1518      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]>;1519      /**1520       * Set specific permissions of a collection. Empty, or None fields mean chain default.1521       * 1522       * # Permissions1523       * 1524       * * Collection owner1525       * * Collection admin1526       * 1527       * # Arguments1528       * 1529       * * `collection_id`: ID of the modified collection.1530       * * `new_permission`: New permissions of the collection. Fields that are not set (None)1531       * will not overwrite the old ones.1532       **/1533      setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1534      /**1535       * Add or change collection properties.1536       * 1537       * # Permissions1538       * 1539       * * Collection owner1540       * * Collection admin1541       * 1542       * # Arguments1543       * 1544       * * `collection_id`: ID of the modified collection.1545       * * `properties`: Vector of key-value pairs stored as the collection's metadata.1546       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1547       **/1548      setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1549      /**1550       * Set (invite) a new collection sponsor.1551       * 1552       * If successful, confirmation from the sponsor-to-be will be pending.1553       * 1554       * # Permissions1555       * 1556       * * Collection owner1557       * * Collection admin1558       * 1559       * # Arguments1560       * 1561       * * `collection_id`: ID of the modified collection.1562       * * `new_sponsor`: ID of the account of the sponsor-to-be.1563       **/1564      setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1565      /**1566       * Add or change token properties according to collection's permissions.1567       * Currently properties only work with NFTs.1568       * 1569       * # Permissions1570       * 1571       * * Depends on collection's token property permissions and specified property mutability:1572       * * Collection owner1573       * * Collection admin1574       * * Token owner1575       * 1576       * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1577       * 1578       * # Arguments1579       * 1580       * * `collection_id: ID of the collection to which the token belongs.1581       * * `token_id`: ID of the modified token.1582       * * `properties`: Vector of key-value pairs stored as the token's metadata.1583       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1584       **/1585      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>]>;1586      /**1587       * Add or change token property permissions of a collection.1588       * 1589       * Without a permission for a particular key, a property with that key1590       * cannot be created in a token.1591       * 1592       * # Permissions1593       * 1594       * * Collection owner1595       * * Collection admin1596       * 1597       * # Arguments1598       * 1599       * * `collection_id`: ID of the modified collection.1600       * * `property_permissions`: Vector of permissions for property keys.1601       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1602       **/1603      setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1604      /**1605       * Completely allow or disallow transfers for a particular collection.1606       * 1607       * # Permissions1608       * 1609       * * Collection owner1610       * 1611       * # Arguments1612       * 1613       * * `collection_id`: ID of the collection.1614       * * `value`: New value of the flag, are transfers allowed?1615       **/1616      setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1617      /**1618       * Change ownership of the token.1619       * 1620       * # Permissions1621       * 1622       * * Collection owner1623       * * Collection admin1624       * * Current token owner1625       * 1626       * # Arguments1627       * 1628       * * `recipient`: Address of token recipient.1629       * * `collection_id`: ID of the collection the item belongs to.1630       * * `item_id`: ID of the item.1631       * * Non-Fungible Mode: Required.1632       * * Fungible Mode: Ignored.1633       * * Re-Fungible Mode: Required.1634       * 1635       * * `value`: Amount to transfer.1636       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1637       * * Fungible Mode: The desired number of pieces to transfer.1638       * * Re-Fungible Mode: The desired number of pieces to transfer.1639       **/1640      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]>;1641      /**1642       * Change ownership of an item on behalf of the owner as a non-owner account.1643       * 1644       * See the [`approve`][`Pallet::approve`] method for additional information.1645       * 1646       * After this method executes, one approval is removed from the total so that1647       * the approved address will not be able to transfer this item again from this owner.1648       * 1649       * # Permissions1650       * 1651       * * Collection owner1652       * * Collection admin1653       * * Current item owner1654       * * Address approved by current item owner1655       * 1656       * # Arguments1657       * 1658       * * `from`: Address that currently owns the token.1659       * * `recipient`: Address of the new token-owner-to-be.1660       * * `collection_id`: ID of the collection the item.1661       * * `item_id`: ID of the item to be transferred.1662       * * `value`: Amount to transfer.1663       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1664       * * Fungible Mode: The desired number of pieces to transfer.1665       * * Re-Fungible Mode: The desired number of pieces to transfer.1666       **/1667      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]>;1668      /**1669       * Generic tx1670       **/1671      [key: string]: SubmittableExtrinsicFunction<ApiType>;1672    };1673    vesting: {1674      claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1675      claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1676      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>]>;1677      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]>;1678      /**1679       * Generic tx1680       **/1681      [key: string]: SubmittableExtrinsicFunction<ApiType>;1682    };1683    xcmpQueue: {1684      /**1685       * Resumes all XCM executions for the XCMP queue.1686       * 1687       * Note that this function doesn't change the status of the in/out bound channels.1688       * 1689       * - `origin`: Must pass `ControllerOrigin`.1690       **/1691      resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1692      /**1693       * Services a single overweight XCM.1694       * 1695       * - `origin`: Must pass `ExecuteOverweightOrigin`.1696       * - `index`: The index of the overweight XCM to service1697       * - `weight_limit`: The amount of weight that XCM execution may take.1698       * 1699       * Errors:1700       * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1701       * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1702       * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1703       * 1704       * Events:1705       * - `OverweightServiced`: On success.1706       **/1707      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, Weight]>;1708      /**1709       * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1710       * 1711       * - `origin`: Must pass `ControllerOrigin`.1712       **/1713      suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1714      /**1715       * Overwrites the number of pages of messages which must be in the queue after which we drop any further1716       * messages from the channel.1717       * 1718       * - `origin`: Must pass `Root`.1719       * - `new`: Desired value for `QueueConfigData.drop_threshold`1720       **/1721      updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1722      /**1723       * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1724       * message sending may recommence after it has been suspended.1725       * 1726       * - `origin`: Must pass `Root`.1727       * - `new`: Desired value for `QueueConfigData.resume_threshold`1728       **/1729      updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1730      /**1731       * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1732       * suspend their sending.1733       * 1734       * - `origin`: Must pass `Root`.1735       * - `new`: Desired value for `QueueConfigData.suspend_value`1736       **/1737      updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1738      /**1739       * Overwrites the amount of remaining weight under which we stop processing messages.1740       * 1741       * - `origin`: Must pass `Root`.1742       * - `new`: Desired value for `QueueConfigData.threshold_weight`1743       **/1744      updateThresholdWeight: AugmentedSubmittable<(updated: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Weight]>;1745      /**1746       * Overwrites the speed to which the available weight approaches the maximum weight.1747       * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1748       * 1749       * - `origin`: Must pass `Root`.1750       * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1751       **/1752      updateWeightRestrictDecay: AugmentedSubmittable<(updated: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Weight]>;1753      /**1754       * Overwrite the maximum amount of weight any individual message may consume.1755       * Messages above this weight go into the overweight queue and may only be serviced explicitly.1756       * 1757       * - `origin`: Must pass `Root`.1758       * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1759       **/1760      updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Weight]>;1761      /**1762       * Generic tx1763       **/1764      [key: string]: SubmittableExtrinsicFunction<ApiType>;1765    };1766    xTokens: {1767      /**1768       * Transfer native currencies.1769       * 1770       * `dest_weight` is the weight for XCM execution on the dest chain, and1771       * it would be charged from the transferred assets. If set below1772       * requirements, the execution may fail and assets wouldn't be1773       * received.1774       * 1775       * It's a no-op if any error on local XCM execution or message sending.1776       * Note sending assets out per se doesn't guarantee they would be1777       * received. Receiving depends on if the XCM message could be delivered1778       * by the network, and if the receiving chain would handle1779       * messages correctly.1780       **/1781      transfer: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, XcmVersionedMultiLocation, u64]>;1782      /**1783       * Transfer `MultiAsset`.1784       * 1785       * `dest_weight` is the weight for XCM execution on the dest chain, and1786       * it would be charged from the transferred assets. If set below1787       * requirements, the execution may fail and assets wouldn't be1788       * received.1789       * 1790       * It's a no-op if any error on local XCM execution or message sending.1791       * Note sending assets out per se doesn't guarantee they would be1792       * received. Receiving depends on if the XCM message could be delivered1793       * by the network, and if the receiving chain would handle1794       * messages correctly.1795       **/1796      transferMultiasset: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiLocation, u64]>;1797      /**1798       * Transfer several `MultiAsset` specifying the item to be used as fee1799       * 1800       * `dest_weight` is the weight for XCM execution on the dest chain, and1801       * it would be charged from the transferred assets. If set below1802       * requirements, the execution may fail and assets wouldn't be1803       * received.1804       * 1805       * `fee_item` is index of the MultiAssets that we want to use for1806       * payment1807       * 1808       * It's a no-op if any error on local XCM execution or message sending.1809       * Note sending assets out per se doesn't guarantee they would be1810       * received. Receiving depends on if the XCM message could be delivered1811       * by the network, and if the receiving chain would handle1812       * messages correctly.1813       **/1814      transferMultiassets: AugmentedSubmittable<(assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAssets, u32, XcmVersionedMultiLocation, u64]>;1815      /**1816       * Transfer `MultiAsset` specifying the fee and amount as separate.1817       * 1818       * `dest_weight` is the weight for XCM execution on the dest chain, and1819       * it would be charged from the transferred assets. If set below1820       * requirements, the execution may fail and assets wouldn't be1821       * received.1822       * 1823       * `fee` is the multiasset to be spent to pay for execution in1824       * destination chain. Both fee and amount will be subtracted form the1825       * callers balance For now we only accept fee and asset having the same1826       * `MultiLocation` id.1827       * 1828       * If `fee` is not high enough to cover for the execution costs in the1829       * destination chain, then the assets will be trapped in the1830       * destination chain1831       * 1832       * It's a no-op if any error on local XCM execution or message sending.1833       * Note sending assets out per se doesn't guarantee they would be1834       * received. Receiving depends on if the XCM message could be delivered1835       * by the network, and if the receiving chain would handle1836       * messages correctly.1837       **/1838      transferMultiassetWithFee: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, fee: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiAsset, XcmVersionedMultiLocation, u64]>;1839      /**1840       * Transfer several currencies specifying the item to be used as fee1841       * 1842       * `dest_weight` is the weight for XCM execution on the dest chain, and1843       * it would be charged from the transferred assets. If set below1844       * requirements, the execution may fail and assets wouldn't be1845       * received.1846       * 1847       * `fee_item` is index of the currencies tuple that we want to use for1848       * payment1849       * 1850       * It's a no-op if any error on local XCM execution or message sending.1851       * Note sending assets out per se doesn't guarantee they would be1852       * received. Receiving depends on if the XCM message could be delivered1853       * by the network, and if the receiving chain would handle1854       * messages correctly.1855       **/1856      transferMulticurrencies: AugmentedSubmittable<(currencies: Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>> | ([PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, u128 | AnyNumber | Uint8Array])[], feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>>, u32, XcmVersionedMultiLocation, u64]>;1857      /**1858       * Transfer native currencies specifying the fee and amount as1859       * separate.1860       * 1861       * `dest_weight` is the weight for XCM execution on the dest chain, and1862       * it would be charged from the transferred assets. If set below1863       * requirements, the execution may fail and assets wouldn't be1864       * received.1865       * 1866       * `fee` is the amount to be spent to pay for execution in destination1867       * chain. Both fee and amount will be subtracted form the callers1868       * balance.1869       * 1870       * If `fee` is not high enough to cover for the execution costs in the1871       * destination chain, then the assets will be trapped in the1872       * destination chain1873       * 1874       * It's a no-op if any error on local XCM execution or message sending.1875       * Note sending assets out per se doesn't guarantee they would be1876       * received. Receiving depends on if the XCM message could be delivered1877       * by the network, and if the receiving chain would handle1878       * messages correctly.1879       **/1880      transferWithFee: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, fee: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, u128, XcmVersionedMultiLocation, u64]>;1881      /**1882       * Generic tx1883       **/1884      [key: string]: SubmittableExtrinsicFunction<ApiType>;1885    };1886  } // AugmentedSubmittables1887} // declare module