git.delta.rocks / unique-network / refs/commits / 507b779dd4fb

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