`d46d545daa01`

source

tests/src/interfaces/augment-api-tx.ts103.8 KiBsource history
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<<<<<<< HEAD221      setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;222      setXcmAllowedLocations: AugmentedSubmittable<(locations: Option<Vec<XcmV1MultiLocation>> | null | Uint8Array | Vec<XcmV1MultiLocation> | (XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<Vec<XcmV1MultiLocation>>]>;223=======224      setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;225>>>>>>> chore: regenerate types226      /**227       * Generic tx228       **/229      [key: string]: SubmittableExtrinsicFunction<ApiType>;230    };231    cumulusXcm: {232      /**233       * Generic tx234       **/235      [key: string]: SubmittableExtrinsicFunction<ApiType>;236    };237    dmpQueue: {238      /**239       * Service a single overweight message.240       * 241       * - `origin`: Must pass `ExecuteOverweightOrigin`.242       * - `index`: The index of the overweight message to service.243       * - `weight_limit`: The amount of weight that message execution may take.244       * 245       * Errors:246       * - `Unknown`: Message of `index` is unknown.247       * - `OverLimit`: Message execution may use greater than `weight_limit`.248       * 249       * Events:250       * - `OverweightServiced`: On success.251       **/252      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;253      /**254       * Generic tx255       **/256      [key: string]: SubmittableExtrinsicFunction<ApiType>;257    };258    ethereum: {259      /**260       * Transact an Ethereum transaction.261       **/262      transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;263      /**264       * Generic tx265       **/266      [key: string]: SubmittableExtrinsicFunction<ApiType>;267    };268    evm: {269      /**270       * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.271       **/272      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>]>>]>;273      /**274       * Issue an EVM create operation. This is similar to a contract creation transaction in275       * Ethereum.276       **/277      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>]>>]>;278      /**279       * Issue an EVM create2 operation.280       **/281      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>]>>]>;282      /**283       * Withdraw balance from EVM into currency/balances pallet.284       **/285      withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;286      /**287       * Generic tx288       **/289      [key: string]: SubmittableExtrinsicFunction<ApiType>;290    };291    evmMigration: {292      /**293       * Start contract migration, inserts contract stub at target address,294       * and marks account as pending, allowing to insert storage295       **/296      begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;297      /**298       * Finish contract migration, allows it to be called.299       * It is not possible to alter contract storage via [`Self::set_data`]300       * after this call.301       **/302      finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;303      /**304       * Create ethereum events attached to the fake transaction305       **/306      insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;307      /**308       * Create substrate events309       **/310      insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;311      /**312       * Insert items into contract storage, this method can be called313       * multiple times314       **/315      setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;316      /**317       * Generic tx318       **/319      [key: string]: SubmittableExtrinsicFunction<ApiType>;320    };321    foreignAssets: {322      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]>;323      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]>;324      /**325       * Generic tx326       **/327      [key: string]: SubmittableExtrinsicFunction<ApiType>;328    };329    inflation: {330      /**331       * This method sets the inflation start date. Can be only called once.332       * Inflation start block can be backdated and will catch up. The method will create Treasury333       * account if it does not exist and perform the first inflation deposit.334       * 335       * # Permissions336       * 337       * * Root338       * 339       * # Arguments340       * 341       * * inflation_start_relay_block: The relay chain block at which inflation should start342       **/343      startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;344      /**345       * Generic tx346       **/347      [key: string]: SubmittableExtrinsicFunction<ApiType>;348    };349    maintenance: {350      disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;351      enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;352      /**353       * Generic tx354       **/355      [key: string]: SubmittableExtrinsicFunction<ApiType>;356    };357    parachainSystem: {358      authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;359      enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;360      /**361       * Set the current validation data.362       * 363       * This should be invoked exactly once per block. It will panic at the finalization364       * phase if the call was not invoked.365       * 366       * The dispatch origin for this call must be `Inherent`367       * 368       * As a side effect, this function upgrades the current validation function369       * if the appropriate time has come.370       **/371      setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;372      sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;373      /**374       * Generic tx375       **/376      [key: string]: SubmittableExtrinsicFunction<ApiType>;377    };378    polkadotXcm: {379      /**380       * Execute an XCM message from a local, signed, origin.381       * 382       * An event is deposited indicating whether `msg` could be executed completely or only383       * partially.384       * 385       * No more than `max_weight` will be used in its attempted execution. If this is less than the386       * maximum amount of weight that the message could take to be executed, then no execution387       * attempt will be made.388       * 389       * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully390       * to completion; only that *some* of it was executed.391       **/392      execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;393      /**394       * Set a safe XCM version (the version that XCM should be encoded with if the most recent395       * version a destination can accept is unknown).396       * 397       * - `origin`: Must be Root.398       * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.399       **/400      forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;401      /**402       * Ask a location to notify us regarding their XCM version and any changes to it.403       * 404       * - `origin`: Must be Root.405       * - `location`: The location to which we should subscribe for XCM version notifications.406       **/407      forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;408      /**409       * Require that a particular destination should no longer notify us regarding any XCM410       * version changes.411       * 412       * - `origin`: Must be Root.413       * - `location`: The location to which we are currently subscribed for XCM version414       * notifications which we no longer desire.415       **/416      forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;417      /**418       * Extoll that a particular destination can be communicated with through a particular419       * version of XCM.420       * 421       * - `origin`: Must be Root.422       * - `location`: The destination that is being described.423       * - `xcm_version`: The latest version of XCM that `location` supports.424       **/425      forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;426      /**427       * Transfer some assets from the local chain to the sovereign account of a destination428       * chain and forward a notification XCM.429       * 430       * Fee payment on the destination side is made from the asset in the `assets` vector of431       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight432       * is needed than `weight_limit`, then the operation will fail and the assets send may be433       * at risk.434       * 435       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.436       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send437       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.438       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be439       * an `AccountId32` value.440       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the441       * `dest` side.442       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay443       * fees.444       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.445       **/446      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]>;447      /**448       * Teleport some assets from the local chain to some destination chain.449       * 450       * Fee payment on the destination side is made from the asset in the `assets` vector of451       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight452       * is needed than `weight_limit`, then the operation will fail and the assets send may be453       * at risk.454       * 455       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.456       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send457       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.458       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be459       * an `AccountId32` value.460       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the461       * `dest` side. May not be empty.462       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay463       * fees.464       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.465       **/466      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]>;467      /**468       * Transfer some assets from the local chain to the sovereign account of a destination469       * chain and forward a notification XCM.470       * 471       * Fee payment on the destination side is made from the asset in the `assets` vector of472       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,473       * with all fees taken as needed from the asset.474       * 475       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.476       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send477       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.478       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be479       * an `AccountId32` value.480       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the481       * `dest` side.482       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay483       * fees.484       **/485      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]>;486      send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;487      /**488       * Teleport some assets from the local chain to some destination chain.489       * 490       * Fee payment on the destination side is made from the asset in the `assets` vector of491       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,492       * with all fees taken as needed from the asset.493       * 494       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.495       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send496       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.497       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be498       * an `AccountId32` value.499       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the500       * `dest` side. May not be empty.501       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay502       * fees.503       **/504      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]>;505      /**506       * Generic tx507       **/508      [key: string]: SubmittableExtrinsicFunction<ApiType>;509    };510    rmrkCore: {511      /**512       * Accept an NFT sent from another account to self or an owned NFT.513       * 514       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.515       * 516       * # Permissions:517       * - Token-owner-to-be518       * 519       * # Arguments:520       * - `origin`: sender of the transaction521       * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.522       * - `rmrk_nft_id`: ID of the NFT to be accepted.523       * - `new_owner`: Either the sender's account ID or a sender-owned NFT,524       * whichever the accepted NFT was sent to.525       **/526      acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;527      /**528       * Accept the addition of a newly created pending resource to an existing NFT.529       * 530       * This transaction is needed when a resource is created and assigned to an NFT531       * by a non-owner, i.e. the collection issuer, with one of the532       * [`add_...` transactions](Pallet::add_basic_resource).533       * 534       * # Permissions:535       * - Token owner536       * 537       * # Arguments:538       * - `origin`: sender of the transaction539       * - `rmrk_collection_id`: RMRK collection ID of the NFT.540       * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.541       * - `resource_id`: ID of the newly created pending resource.542       * accept the addition of a new resource to an existing NFT543       **/544      acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;545      /**546       * Accept the removal of a removal-pending resource from an NFT.547       * 548       * This transaction is needed when a non-owner, i.e. the collection issuer,549       * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.550       * 551       * # Permissions:552       * - Token owner553       * 554       * # Arguments:555       * - `origin`: sender of the transaction556       * - `rmrk_collection_id`: RMRK collection ID of the NFT.557       * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.558       * - `resource_id`: ID of the removal-pending resource.559       **/560      acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;561      /**562       * Create and set/propose a basic resource for an NFT.563       * 564       * A basic resource is the simplest, lacking a Base and anything that comes with it.565       * See RMRK docs for more information and examples.566       * 567       * # Permissions:568       * - Collection issuer - if not the token owner, adding the resource will warrant569       * the owner's [acceptance](Pallet::accept_resource).570       * 571       * # Arguments:572       * - `origin`: sender of the transaction573       * - `rmrk_collection_id`: RMRK collection ID of the NFT.574       * - `nft_id`: ID of the NFT to assign a resource to.575       * - `resource`: Data of the resource to be created.576       **/577      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]>;578      /**579       * Create and set/propose a composable resource for an NFT.580       * 581       * A composable resource links to a Base and has a subset of its Parts it is composed of.582       * See RMRK docs for more information and examples.583       * 584       * # Permissions:585       * - Collection issuer - if not the token owner, adding the resource will warrant586       * the owner's [acceptance](Pallet::accept_resource).587       * 588       * # Arguments:589       * - `origin`: sender of the transaction590       * - `rmrk_collection_id`: RMRK collection ID of the NFT.591       * - `nft_id`: ID of the NFT to assign a resource to.592       * - `resource`: Data of the resource to be created.593       **/594      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]>;595      /**596       * Create and set/propose a slot resource for an NFT.597       * 598       * A slot resource links to a Base and a slot ID in it which it can fit into.599       * See RMRK docs for more information and examples.600       * 601       * # Permissions:602       * - Collection issuer - if not the token owner, adding the resource will warrant603       * the owner's [acceptance](Pallet::accept_resource).604       * 605       * # Arguments:606       * - `origin`: sender of the transaction607       * - `rmrk_collection_id`: RMRK collection ID of the NFT.608       * - `nft_id`: ID of the NFT to assign a resource to.609       * - `resource`: Data of the resource to be created.610       **/611      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]>;612      /**613       * Burn an NFT, destroying it and its nested tokens up to the specified limit.614       * If the burning budget is exceeded, the transaction is reverted.615       * 616       * This is the way to burn a nested token as well.617       * 618       * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).619       * 620       * # Permissions:621       * * Token owner622       * 623       * # Arguments:624       * - `origin`: sender of the transaction625       * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.626       * - `nft_id`: ID of the NFT to be destroyed.627       * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction628       * is reverted if there are more tokens to burn in the nesting tree than this number.629       * This is primarily a mechanism of transaction weight control.630       **/631      burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;632      /**633       * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).634       * 635       * # Permissions:636       * * Collection issuer637       * 638       * # Arguments:639       * - `origin`: sender of the transaction640       * - `collection_id`: RMRK collection ID to change the issuer of.641       * - `new_issuer`: Collection's new issuer.642       **/643      changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;644      /**645       * Create a new collection of NFTs.646       * 647       * # Permissions:648       * * Anyone - will be assigned as the issuer of the collection.649       * 650       * # Arguments:651       * - `origin`: sender of the transaction652       * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.653       * - `max`: Optional maximum number of tokens.654       * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.655       * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.656       **/657      createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;658      /**659       * Destroy a collection.660       * 661       * Only empty collections can be destroyed. If it has any tokens, they must be burned first.662       * 663       * # Permissions:664       * * Collection issuer665       * 666       * # Arguments:667       * - `origin`: sender of the transaction668       * - `collection_id`: RMRK ID of the collection to destroy.669       **/670      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;671      /**672       * "Lock" the collection and prevent new token creation. Cannot be undone.673       * 674       * # Permissions:675       * * Collection issuer676       * 677       * # Arguments:678       * - `origin`: sender of the transaction679       * - `collection_id`: RMRK ID of the collection to lock.680       **/681      lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;682      /**683       * Mint an NFT in a specified collection.684       * 685       * # Permissions:686       * * Collection issuer687       * 688       * # Arguments:689       * - `origin`: sender of the transaction690       * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).691       * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.692       * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.693       * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.694       * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.695       * - `transferable`: Can this NFT be transferred? Cannot be changed.696       * - `resources`: Resource data to be added to the NFT immediately after minting.697       **/698      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>>]>;699      /**700       * Reject an NFT sent from another account to self or owned NFT.701       * The NFT in question will not be sent back and burnt instead.702       * 703       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.704       * 705       * # Permissions:706       * - Token-owner-to-be-not707       * 708       * # Arguments:709       * - `origin`: sender of the transaction710       * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.711       * - `rmrk_nft_id`: ID of the NFT to be rejected.712       **/713      rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;714      /**715       * Remove and erase a resource from an NFT.716       * 717       * If the sender does not own the NFT, then it will be pending confirmation,718       * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.719       * 720       * # Permissions721       * - Collection issuer722       * 723       * # Arguments724       * - `origin`: sender of the transaction725       * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.726       * - `nft_id`: ID of the NFT with a resource to be removed.727       * - `resource_id`: ID of the resource to be removed.728       **/729      removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;730      /**731       * Transfer an NFT from an account/NFT A to another account/NFT B.732       * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].733       * 734       * If the target owner is an NFT owned by another account, then the NFT will enter735       * the pending state and will have to be accepted by the other account.736       * 737       * # Permissions:738       * - Token owner739       * 740       * # Arguments:741       * - `origin`: sender of the transaction742       * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.743       * - `rmrk_nft_id`: ID of the NFT to be transferred.744       * - `new_owner`: New owner of the nft which can be either an account or a NFT.745       **/746      send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;747      /**748       * Set a different order of resource priorities for an NFT. Priorities can be used,749       * for example, for order of rendering.750       * 751       * Note that the priorities are not updated automatically, and are an empty vector752       * by default. There is no pre-set definition for the order to be particular,753       * it can be interpreted arbitrarily use-case by use-case.754       * 755       * # Permissions:756       * - Token owner757       * 758       * # Arguments:759       * - `origin`: sender of the transaction760       * - `rmrk_collection_id`: RMRK collection ID of the NFT.761       * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.762       * - `priorities`: Ordered vector of resource IDs.763       **/764      setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;765      /**766       * Add or edit a custom user property, a key-value pair, describing the metadata767       * of a token or a collection, on either one of these.768       * 769       * Note that in this proxy implementation many details regarding RMRK are stored770       * as scoped properties prefixed with "rmrk:", normally inaccessible771       * to external transactions and RPCs.772       * 773       * # Permissions:774       * - Collection issuer - in case of collection property775       * - Token owner - in case of NFT property776       * 777       * # Arguments:778       * - `origin`: sender of the transaction779       * - `rmrk_collection_id`: RMRK collection ID.780       * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.781       * - `key`: Key of the custom property to be referenced by.782       * - `value`: Value of the custom property to be stored.783       **/784      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]>;785      /**786       * Generic tx787       **/788      [key: string]: SubmittableExtrinsicFunction<ApiType>;789    };790    rmrkEquip: {791      /**792       * Create a new Base.793       * 794       * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)795       * 796       * # Permissions797       * - Anyone - will be assigned as the issuer of the Base.798       * 799       * # Arguments:800       * - `origin`: Caller, will be assigned as the issuer of the Base801       * - `base_type`: Arbitrary media type, e.g. "svg".802       * - `symbol`: Arbitrary client-chosen symbol.803       * - `parts`: Array of Fixed and Slot Parts composing the Base,804       * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).805       **/806      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>]>;807      /**808       * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.809       * 810       * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).811       * 812       * # Permissions:813       * - Base issuer814       * 815       * # Arguments:816       * - `origin`: sender of the transaction817       * - `base_id`: Base containing the Slot Part to be updated.818       * - `slot_id`: Slot Part whose Equippable List is being updated .819       * - `equippables`: List of equippables that will override the current Equippables list.820       **/821      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]>;822      /**823       * Add a Theme to a Base.824       * A Theme named "default" is required prior to adding other Themes.825       * 826       * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).827       * 828       * # Permissions:829       * - Base issuer830       * 831       * # Arguments:832       * - `origin`: sender of the transaction833       * - `base_id`: Base ID containing the Theme to be updated.834       * - `theme`: Theme to add to the Base.  A Theme has a name and properties, which are an835       * array of [key, value, inherit].836       * - `key`: Arbitrary BoundedString, defined by client.837       * - `value`: Arbitrary BoundedString, defined by client.838       * - `inherit`: Optional bool.839       **/840      themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;841      /**842       * Generic tx843       **/844      [key: string]: SubmittableExtrinsicFunction<ApiType>;845    };846    structure: {847      /**848       * Generic tx849       **/850      [key: string]: SubmittableExtrinsicFunction<ApiType>;851    };852    sudo: {853      /**854       * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo855       * key.856       * 857       * The dispatch origin for this call must be _Signed_.858       * 859       * # <weight>860       * - O(1).861       * - Limited storage reads.862       * - One DB change.863       * # </weight>864       **/865      setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;866      /**867       * Authenticates the sudo key and dispatches a function call with `Root` origin.868       * 869       * The dispatch origin for this call must be _Signed_.870       * 871       * # <weight>872       * - O(1).873       * - Limited storage reads.874       * - One DB write (event).875       * - Weight of derivative `call` execution + 10,000.876       * # </weight>877       **/878      sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;879      /**880       * Authenticates the sudo key and dispatches a function call with `Signed` origin from881       * a given account.882       * 883       * The dispatch origin for this call must be _Signed_.884       * 885       * # <weight>886       * - O(1).887       * - Limited storage reads.888       * - One DB write (event).889       * - Weight of derivative `call` execution + 10,000.890       * # </weight>891       **/892      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]>;893      /**894       * Authenticates the sudo key and dispatches a function call with `Root` origin.895       * This function does not check the weight of the call, and instead allows the896       * Sudo user to specify the weight of the call.897       * 898       * The dispatch origin for this call must be _Signed_.899       * 900       * # <weight>901       * - O(1).902       * - The weight of this call is defined by the caller.903       * # </weight>904       **/905      sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;906      /**907       * Generic tx908       **/909      [key: string]: SubmittableExtrinsicFunction<ApiType>;910    };911    system: {912      /**913       * A dispatch that will fill the block weight up to the given ratio.914       **/915      fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;916      /**917       * Kill all storage items with a key that starts with the given prefix.918       * 919       * **NOTE:** We rely on the Root origin to provide us the number of subkeys under920       * the prefix we are removing to accurately calculate the weight of this function.921       **/922      killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;923      /**924       * Kill some items from storage.925       **/926      killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;927      /**928       * Make some on-chain remark.929       * 930       * # <weight>931       * - `O(1)`932       * # </weight>933       **/934      remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;935      /**936       * Make some on-chain remark and emit event.937       **/938      remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;939      /**940       * Set the new runtime code.941       * 942       * # <weight>943       * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`944       * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is945       * expensive).946       * - 1 storage write (codec `O(C)`).947       * - 1 digest item.948       * - 1 event.949       * The weight of this function is dependent on the runtime, but generally this is very950       * expensive. We will treat this as a full block.951       * # </weight>952       **/953      setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;954      /**955       * Set the new runtime code without doing any checks of the given `code`.956       * 957       * # <weight>958       * - `O(C)` where `C` length of `code`959       * - 1 storage write (codec `O(C)`).960       * - 1 digest item.961       * - 1 event.962       * The weight of this function is dependent on the runtime. We will treat this as a full963       * block. # </weight>964       **/965      setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;966      /**967       * Set the number of pages in the WebAssembly environment's heap.968       **/969      setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;970      /**971       * Set some items of storage.972       **/973      setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;974      /**975       * Generic tx976       **/977      [key: string]: SubmittableExtrinsicFunction<ApiType>;978    };979    testUtils: {980      batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;981      enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;982      incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;983      justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;984      setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;985      setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;986      /**987       * Generic tx988       **/989      [key: string]: SubmittableExtrinsicFunction<ApiType>;990    };991    timestamp: {992      /**993       * Set the current time.994       * 995       * This call should be invoked exactly once per block. It will panic at the finalization996       * phase, if this call hasn't been invoked by that time.997       * 998       * The timestamp should be greater than the previous one by the amount specified by999       * `MinimumPeriod`.1000       * 1001       * The dispatch origin for this call must be `Inherent`.1002       * 1003       * # <weight>1004       * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1005       * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1006       * `on_finalize`)1007       * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1008       * # </weight>1009       **/1010      set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1011      /**1012       * Generic tx1013       **/1014      [key: string]: SubmittableExtrinsicFunction<ApiType>;1015    };1016    tokens: {1017      /**1018       * Exactly as `transfer`, except the origin must be root and the source1019       * account may be specified.1020       * 1021       * The dispatch origin for this call must be _Root_.1022       * 1023       * - `source`: The sender of the transfer.1024       * - `dest`: The recipient of the transfer.1025       * - `currency_id`: currency type.1026       * - `amount`: free balance amount to tranfer.1027       **/1028      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>]>;1029      /**1030       * Set the balances of a given account.1031       * 1032       * This will alter `FreeBalance` and `ReservedBalance` in storage. it1033       * will also decrease the total issuance of the system1034       * (`TotalIssuance`). If the new free or reserved balance is below the1035       * existential deposit, it will reap the `AccountInfo`.1036       * 1037       * The dispatch origin for this call is `root`.1038       **/1039      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>]>;1040      /**1041       * Transfer some liquid free balance to another account.1042       * 1043       * `transfer` will set the `FreeBalance` of the sender and receiver.1044       * It will decrease the total issuance of the system by the1045       * `TransferFee`. If the sender's account is below the existential1046       * deposit as a result of the transfer, the account will be reaped.1047       * 1048       * The dispatch origin for this call must be `Signed` by the1049       * transactor.1050       * 1051       * - `dest`: The recipient of the transfer.1052       * - `currency_id`: currency type.1053       * - `amount`: free balance amount to tranfer.1054       **/1055      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>]>;1056      /**1057       * Transfer all remaining balance to the given account.1058       * 1059       * NOTE: This function only attempts to transfer _transferable_1060       * balances. This means that any locked, reserved, or existential1061       * deposits (when `keep_alive` is `true`), will not be transferred by1062       * this function. To ensure that this function results in a killed1063       * account, you might need to prepare the account by removing any1064       * reference counters, storage deposits, etc...1065       * 1066       * The dispatch origin for this call must be `Signed` by the1067       * transactor.1068       * 1069       * - `dest`: The recipient of the transfer.1070       * - `currency_id`: currency type.1071       * - `keep_alive`: A boolean to determine if the `transfer_all`1072       * operation should send all of the funds the account has, causing1073       * the sender account to be killed (false), or transfer everything1074       * except at least the existential deposit, which will guarantee to1075       * keep the sender account alive (true).1076       **/1077      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]>;1078      /**1079       * Same as the [`transfer`] call, but with a check that the transfer1080       * will not kill the origin account.1081       * 1082       * 99% of the time you want [`transfer`] instead.1083       * 1084       * The dispatch origin for this call must be `Signed` by the1085       * transactor.1086       * 1087       * - `dest`: The recipient of the transfer.1088       * - `currency_id`: currency type.1089       * - `amount`: free balance amount to tranfer.1090       **/1091      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>]>;1092      /**1093       * Generic tx1094       **/1095      [key: string]: SubmittableExtrinsicFunction<ApiType>;1096    };1097    treasury: {1098      /**1099       * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1100       * and the original deposit will be returned.1101       * 1102       * May only be called from `T::ApproveOrigin`.1103       * 1104       * # <weight>1105       * - Complexity: O(1).1106       * - DbReads: `Proposals`, `Approvals`1107       * - DbWrite: `Approvals`1108       * # </weight>1109       **/1110      approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1111      /**1112       * Put forward a suggestion for spending. A deposit proportional to the value1113       * is reserved and slashed if the proposal is rejected. It is returned once the1114       * proposal is awarded.1115       * 1116       * # <weight>1117       * - Complexity: O(1)1118       * - DbReads: `ProposalCount`, `origin account`1119       * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1120       * # </weight>1121       **/1122      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]>;1123      /**1124       * Reject a proposed spend. The original deposit will be slashed.1125       * 1126       * May only be called from `T::RejectOrigin`.1127       * 1128       * # <weight>1129       * - Complexity: O(1)1130       * - DbReads: `Proposals`, `rejected proposer account`1131       * - DbWrites: `Proposals`, `rejected proposer account`1132       * # </weight>1133       **/1134      rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1135      /**1136       * Force a previously approved proposal to be removed from the approval queue.1137       * The original deposit will no longer be returned.1138       * 1139       * May only be called from `T::RejectOrigin`.1140       * - `proposal_id`: The index of a proposal1141       * 1142       * # <weight>1143       * - Complexity: O(A) where `A` is the number of approvals1144       * - Db reads and writes: `Approvals`1145       * # </weight>1146       * 1147       * Errors:1148       * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1149       * i.e., the proposal has not been approved. This could also mean the proposal does not1150       * exist altogether, thus there is no way it would have been approved in the first place.1151       **/1152      removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1153      /**1154       * Propose and approve a spend of treasury funds.1155       * 1156       * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1157       * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1158       * - `beneficiary`: The destination account for the transfer.1159       * 1160       * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1161       * beneficiary.1162       **/1163      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]>;1164      /**1165       * Generic tx1166       **/1167      [key: string]: SubmittableExtrinsicFunction<ApiType>;1168    };1169    unique: {1170      /**1171       * Add an admin to a collection.1172       * 1173       * NFT Collection can be controlled by multiple admin addresses1174       * (some which can also be servers, for example). Admins can issue1175       * and burn NFTs, as well as add and remove other admins,1176       * but cannot change NFT or Collection ownership.1177       * 1178       * # Permissions1179       * 1180       * * Collection owner1181       * * Collection admin1182       * 1183       * # Arguments1184       * 1185       * * `collection_id`: ID of the Collection to add an admin for.1186       * * `new_admin`: Address of new admin to add.1187       **/1188      addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1189      /**1190       * Add an address to allow list.1191       * 1192       * # Permissions1193       * 1194       * * Collection owner1195       * * Collection admin1196       * 1197       * # Arguments1198       * 1199       * * `collection_id`: ID of the modified collection.1200       * * `address`: ID of the address to be added to the allowlist.1201       **/1202      addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1203      /**1204       * Allow a non-permissioned address to transfer or burn an item.1205       * 1206       * # Permissions1207       * 1208       * * Collection owner1209       * * Collection admin1210       * * Current item owner1211       * 1212       * # Arguments1213       * 1214       * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1215       * * `collection_id`: ID of the collection the item belongs to.1216       * * `item_id`: ID of the item transactions on which are now approved.1217       * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1218       * Set to 0 to revoke the approval.1219       **/1220      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]>;1221      /**1222       * Destroy a token on behalf of the owner as a non-owner account.1223       * 1224       * See also: [`approve`][`Pallet::approve`].1225       * 1226       * After this method executes, one approval is removed from the total so that1227       * the approved address will not be able to transfer this item again from this owner.1228       * 1229       * # Permissions1230       * 1231       * * Collection owner1232       * * Collection admin1233       * * Current token owner1234       * * Address approved by current item owner1235       * 1236       * # Arguments1237       * 1238       * * `from`: The owner of the burning item.1239       * * `collection_id`: ID of the collection to which the item belongs.1240       * * `item_id`: ID of item to burn.1241       * * `value`: Number of pieces to burn.1242       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1243       * * Fungible Mode: The desired number of pieces to burn.1244       * * Re-Fungible Mode: The desired number of pieces to burn.1245       **/1246      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]>;1247      /**1248       * Destroy an item.1249       * 1250       * # Permissions1251       * 1252       * * Collection owner1253       * * Collection admin1254       * * Current item owner1255       * 1256       * # Arguments1257       * 1258       * * `collection_id`: ID of the collection to which the item belongs.1259       * * `item_id`: ID of item to burn.1260       * * `value`: Number of pieces of the item to destroy.1261       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1262       * * Fungible Mode: The desired number of pieces to burn.1263       * * Re-Fungible Mode: The desired number of pieces to burn.1264       **/1265      burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1266      /**1267       * Change the owner of the collection.1268       * 1269       * # Permissions1270       * 1271       * * Collection owner1272       * 1273       * # Arguments1274       * 1275       * * `collection_id`: ID of the modified collection.1276       * * `new_owner`: ID of the account that will become the owner.1277       **/1278      changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1279      /**1280       * Confirm own sponsorship of a collection, becoming the sponsor.1281       * 1282       * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1283       * Sponsor can pay the fees of a transaction instead of the sender,1284       * but only within specified limits.1285       * 1286       * # Permissions1287       * 1288       * * Sponsor-to-be1289       * 1290       * # Arguments1291       * 1292       * * `collection_id`: ID of the collection with the pending sponsor.1293       **/1294      confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1295      /**1296       * Create a collection of tokens.1297       * 1298       * Each Token may have multiple properties encoded as an array of bytes1299       * of certain length. The initial owner of the collection is set1300       * to the address that signed the transaction and can be changed later.1301       * 1302       * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1303       * 1304       * # Permissions1305       * 1306       * * Anyone - becomes the owner of the new collection.1307       * 1308       * # Arguments1309       * 1310       * * `collection_name`: Wide-character string with collection name1311       * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1312       * * `collection_description`: Wide-character string with collection description1313       * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1314       * * `token_prefix`: Byte string containing the token prefix to mark a collection1315       * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1316       * * `mode`: Type of items stored in the collection and type dependent data.1317       **/1318      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]>;1319      /**1320       * Create a collection with explicit parameters.1321       * 1322       * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1323       * 1324       * # Permissions1325       * 1326       * * Anyone - becomes the owner of the new collection.1327       * 1328       * # Arguments1329       * 1330       * * `data`: Explicit data of a collection used for its creation.1331       **/1332      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]>;1333      /**1334       * Mint an item within a collection.1335       * 1336       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1337       * 1338       * # Permissions1339       * 1340       * * Collection owner1341       * * Collection admin1342       * * Anyone if1343       * * Allow List is enabled, and1344       * * Address is added to allow list, and1345       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1346       * 1347       * # Arguments1348       * 1349       * * `collection_id`: ID of the collection to which an item would belong.1350       * * `owner`: Address of the initial owner of the item.1351       * * `data`: Token data describing the item to store on chain.1352       **/1353      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]>;1354      /**1355       * Create multiple items within a collection.1356       * 1357       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1358       * 1359       * # Permissions1360       * 1361       * * Collection owner1362       * * Collection admin1363       * * Anyone if1364       * * Allow List is enabled, and1365       * * Address is added to the allow list, and1366       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1367       * 1368       * # Arguments1369       * 1370       * * `collection_id`: ID of the collection to which the tokens would belong.1371       * * `owner`: Address of the initial owner of the tokens.1372       * * `items_data`: Vector of data describing each item to be created.1373       **/1374      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>]>;1375      /**1376       * Create multiple items within a collection with explicitly specified initial parameters.1377       * 1378       * # Permissions1379       * 1380       * * Collection owner1381       * * Collection admin1382       * * Anyone if1383       * * Allow List is enabled, and1384       * * Address is added to allow list, and1385       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1386       * 1387       * # Arguments1388       * 1389       * * `collection_id`: ID of the collection to which the tokens would belong.1390       * * `data`: Explicit item creation data.1391       **/1392      createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1393      /**1394       * Delete specified collection properties.1395       * 1396       * # Permissions1397       * 1398       * * Collection Owner1399       * * Collection Admin1400       * 1401       * # Arguments1402       * 1403       * * `collection_id`: ID of the modified collection.1404       * * `property_keys`: Vector of keys of the properties to be deleted.1405       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1406       **/1407      deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1408      /**1409       * Delete specified token properties. Currently properties only work with NFTs.1410       * 1411       * # Permissions1412       * 1413       * * Depends on collection's token property permissions and specified property mutability:1414       * * Collection owner1415       * * Collection admin1416       * * Token owner1417       * 1418       * # Arguments1419       * 1420       * * `collection_id`: ID of the collection to which the token belongs.1421       * * `token_id`: ID of the modified token.1422       * * `property_keys`: Vector of keys of the properties to be deleted.1423       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1424       **/1425      deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1426      /**1427       * Destroy a collection if no tokens exist within.1428       * 1429       * # Permissions1430       * 1431       * * Collection owner1432       * 1433       * # Arguments1434       * 1435       * * `collection_id`: Collection to destroy.1436       **/1437      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1438      /**1439       * Remove admin of a collection.1440       * 1441       * An admin address can remove itself. List of admins may become empty,1442       * in which case only Collection Owner will be able to add an Admin.1443       * 1444       * # Permissions1445       * 1446       * * Collection owner1447       * * Collection admin1448       * 1449       * # Arguments1450       * 1451       * * `collection_id`: ID of the collection to remove the admin for.1452       * * `account_id`: Address of the admin to remove.1453       **/1454      removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1455      /**1456       * Remove a collection's a sponsor, making everyone pay for their own transactions.1457       * 1458       * # Permissions1459       * 1460       * * Collection owner1461       * 1462       * # Arguments1463       * 1464       * * `collection_id`: ID of the collection with the sponsor to remove.1465       **/1466      removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1467      /**1468       * Remove an address from allow list.1469       * 1470       * # Permissions1471       * 1472       * * Collection owner1473       * * Collection admin1474       * 1475       * # Arguments1476       * 1477       * * `collection_id`: ID of the modified collection.1478       * * `address`: ID of the address to be removed from the allowlist.1479       **/1480      removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1481      /**1482       * Repairs a broken item1483       * 1484       * # Arguments1485       * 1486       * * `collection_id`: ID of the collection the item belongs to.1487       * * `item_id`: ID of the item.1488       **/1489      repairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1490      /**1491       * Re-partition a refungible token, while owning all of its parts/pieces.1492       * 1493       * # Permissions1494       * 1495       * * Token owner (must own every part)1496       * 1497       * # Arguments1498       * 1499       * * `collection_id`: ID of the collection the RFT belongs to.1500       * * `token_id`: ID of the RFT.1501       * * `amount`: New number of parts/pieces into which the token shall be partitioned.1502       **/1503      repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1504      /**1505       * Sets or unsets the approval of a given operator.1506       * 1507       * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1508       * 1509       * # Arguments1510       * 1511       * * `owner`: Token owner1512       * * `operator`: Operator1513       * * `approve`: Should operator status be granted or revoked?1514       **/1515      setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1516      /**1517       * Set specific limits of a collection. Empty, or None fields mean chain default.1518       * 1519       * # Permissions1520       * 1521       * * Collection owner1522       * * Collection admin1523       * 1524       * # Arguments1525       * 1526       * * `collection_id`: ID of the modified collection.1527       * * `new_limit`: New limits of the collection. Fields that are not set (None)1528       * will not overwrite the old ones.1529       **/1530      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]>;1531      /**1532       * Set specific permissions of a collection. Empty, or None fields mean chain default.1533       * 1534       * # Permissions1535       * 1536       * * Collection owner1537       * * Collection admin1538       * 1539       * # Arguments1540       * 1541       * * `collection_id`: ID of the modified collection.1542       * * `new_permission`: New permissions of the collection. Fields that are not set (None)1543       * will not overwrite the old ones.1544       **/1545      setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1546      /**1547       * Add or change collection properties.1548       * 1549       * # Permissions1550       * 1551       * * Collection owner1552       * * Collection admin1553       * 1554       * # Arguments1555       * 1556       * * `collection_id`: ID of the modified collection.1557       * * `properties`: Vector of key-value pairs stored as the collection's metadata.1558       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1559       **/1560      setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1561      /**1562       * Set (invite) a new collection sponsor.1563       * 1564       * If successful, confirmation from the sponsor-to-be will be pending.1565       * 1566       * # Permissions1567       * 1568       * * Collection owner1569       * * Collection admin1570       * 1571       * # Arguments1572       * 1573       * * `collection_id`: ID of the modified collection.1574       * * `new_sponsor`: ID of the account of the sponsor-to-be.1575       **/1576      setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1577      /**1578       * Add or change token properties according to collection's permissions.1579       * Currently properties only work with NFTs.1580       * 1581       * # Permissions1582       * 1583       * * Depends on collection's token property permissions and specified property mutability:1584       * * Collection owner1585       * * Collection admin1586       * * Token owner1587       * 1588       * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1589       * 1590       * # Arguments1591       * 1592       * * `collection_id: ID of the collection to which the token belongs.1593       * * `token_id`: ID of the modified token.1594       * * `properties`: Vector of key-value pairs stored as the token's metadata.1595       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1596       **/1597      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>]>;1598      /**1599       * Add or change token property permissions of a collection.1600       * 1601       * Without a permission for a particular key, a property with that key1602       * cannot be created in a token.1603       * 1604       * # Permissions1605       * 1606       * * Collection owner1607       * * Collection admin1608       * 1609       * # Arguments1610       * 1611       * * `collection_id`: ID of the modified collection.1612       * * `property_permissions`: Vector of permissions for property keys.1613       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1614       **/1615      setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1616      /**1617       * Completely allow or disallow transfers for a particular collection.1618       * 1619       * # Permissions1620       * 1621       * * Collection owner1622       * 1623       * # Arguments1624       * 1625       * * `collection_id`: ID of the collection.1626       * * `value`: New value of the flag, are transfers allowed?1627       **/1628      setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1629      /**1630       * Change ownership of the token.1631       * 1632       * # Permissions1633       * 1634       * * Collection owner1635       * * Collection admin1636       * * Current token owner1637       * 1638       * # Arguments1639       * 1640       * * `recipient`: Address of token recipient.1641       * * `collection_id`: ID of the collection the item belongs to.1642       * * `item_id`: ID of the item.1643       * * Non-Fungible Mode: Required.1644       * * Fungible Mode: Ignored.1645       * * Re-Fungible Mode: Required.1646       * 1647       * * `value`: Amount to transfer.1648       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1649       * * Fungible Mode: The desired number of pieces to transfer.1650       * * Re-Fungible Mode: The desired number of pieces to transfer.1651       **/1652      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]>;1653      /**1654       * Change ownership of an item on behalf of the owner as a non-owner account.1655       * 1656       * See the [`approve`][`Pallet::approve`] method for additional information.1657       * 1658       * After this method executes, one approval is removed from the total so that1659       * the approved address will not be able to transfer this item again from this owner.1660       * 1661       * # Permissions1662       * 1663       * * Collection owner1664       * * Collection admin1665       * * Current item owner1666       * * Address approved by current item owner1667       * 1668       * # Arguments1669       * 1670       * * `from`: Address that currently owns the token.1671       * * `recipient`: Address of the new token-owner-to-be.1672       * * `collection_id`: ID of the collection the item.1673       * * `item_id`: ID of the item to be transferred.1674       * * `value`: Amount to transfer.1675       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1676       * * Fungible Mode: The desired number of pieces to transfer.1677       * * Re-Fungible Mode: The desired number of pieces to transfer.1678       **/1679      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]>;1680      /**1681       * Generic tx1682       **/1683      [key: string]: SubmittableExtrinsicFunction<ApiType>;1684    };1685    vesting: {1686      claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1687      claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1688      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>]>;1689      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]>;1690      /**1691       * Generic tx1692       **/1693      [key: string]: SubmittableExtrinsicFunction<ApiType>;1694    };1695    xcmpQueue: {1696      /**1697       * Resumes all XCM executions for the XCMP queue.1698       * 1699       * Note that this function doesn't change the status of the in/out bound channels.1700       * 1701       * - `origin`: Must pass `ControllerOrigin`.1702       **/1703      resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1704      /**1705       * Services a single overweight XCM.1706       * 1707       * - `origin`: Must pass `ExecuteOverweightOrigin`.1708       * - `index`: The index of the overweight XCM to service1709       * - `weight_limit`: The amount of weight that XCM execution may take.1710       * 1711       * Errors:1712       * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1713       * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1714       * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1715       * 1716       * Events:1717       * - `OverweightServiced`: On success.1718       **/1719      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1720      /**1721       * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1722       * 1723       * - `origin`: Must pass `ControllerOrigin`.1724       **/1725      suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1726      /**1727       * Overwrites the number of pages of messages which must be in the queue after which we drop any further1728       * messages from the channel.1729       * 1730       * - `origin`: Must pass `Root`.1731       * - `new`: Desired value for `QueueConfigData.drop_threshold`1732       **/1733      updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1734      /**1735       * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1736       * message sending may recommence after it has been suspended.1737       * 1738       * - `origin`: Must pass `Root`.1739       * - `new`: Desired value for `QueueConfigData.resume_threshold`1740       **/1741      updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1742      /**1743       * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1744       * suspend their sending.1745       * 1746       * - `origin`: Must pass `Root`.1747       * - `new`: Desired value for `QueueConfigData.suspend_value`1748       **/1749      updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1750      /**1751       * Overwrites the amount of remaining weight under which we stop processing messages.1752       * 1753       * - `origin`: Must pass `Root`.1754       * - `new`: Desired value for `QueueConfigData.threshold_weight`1755       **/1756      updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1757      /**1758       * Overwrites the speed to which the available weight approaches the maximum weight.1759       * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1760       * 1761       * - `origin`: Must pass `Root`.1762       * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1763       **/1764      updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1765      /**1766       * Overwrite the maximum amount of weight any individual message may consume.1767       * Messages above this weight go into the overweight queue and may only be serviced explicitly.1768       * 1769       * - `origin`: Must pass `Root`.1770       * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1771       **/1772      updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1773      /**1774       * Generic tx1775       **/1776      [key: string]: SubmittableExtrinsicFunction<ApiType>;1777    };1778    xTokens: {1779      /**1780       * Transfer native currencies.1781       * 1782       * `dest_weight_limit` is the weight for XCM execution on the dest1783       * chain, and it would be charged from the transferred assets. If set1784       * below requirements, the execution may fail and assets wouldn't be1785       * received.1786       * 1787       * It's a no-op if any error on local XCM execution or message sending.1788       * Note sending assets out per se doesn't guarantee they would be1789       * received. Receiving depends on if the XCM message could be delivered1790       * by the network, and if the receiving chain would handle1791       * messages correctly.1792       **/1793      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]>;1794      /**1795       * Transfer `MultiAsset`.1796       * 1797       * `dest_weight_limit` is the weight for XCM execution on the dest1798       * chain, and it would be charged from the transferred assets. If set1799       * below requirements, the execution may fail and assets wouldn't be1800       * received.1801       * 1802       * It's a no-op if any error on local XCM execution or message sending.1803       * Note sending assets out per se doesn't guarantee they would be1804       * received. Receiving depends on if the XCM message could be delivered1805       * by the network, and if the receiving chain would handle1806       * messages correctly.1807       **/1808      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]>;1809      /**1810       * Transfer several `MultiAsset` specifying the item to be used as fee1811       * 1812       * `dest_weight_limit` is the weight for XCM execution on the dest1813       * chain, and it would be charged from the transferred assets. If set1814       * below requirements, the execution may fail and assets wouldn't be1815       * received.1816       * 1817       * `fee_item` is index of the MultiAssets that we want to use for1818       * payment1819       * 1820       * It's a no-op if any error on local XCM execution or message sending.1821       * Note sending assets out per se doesn't guarantee they would be1822       * received. Receiving depends on if the XCM message could be delivered1823       * by the network, and if the receiving chain would handle1824       * messages correctly.1825       **/1826      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]>;1827      /**1828       * Transfer `MultiAsset` specifying the fee and amount as separate.1829       * 1830       * `dest_weight_limit` is the weight for XCM execution on the dest1831       * chain, and it would be charged from the transferred assets. If set1832       * below requirements, the execution may fail and assets wouldn't be1833       * received.1834       * 1835       * `fee` is the multiasset to be spent to pay for execution in1836       * destination chain. Both fee and amount will be subtracted form the1837       * callers balance For now we only accept fee and asset having the same1838       * `MultiLocation` id.1839       * 1840       * If `fee` is not high enough to cover for the execution costs in the1841       * destination chain, then the assets will be trapped in the1842       * destination chain1843       * 1844       * It's a no-op if any error on local XCM execution or message sending.1845       * Note sending assets out per se doesn't guarantee they would be1846       * received. Receiving depends on if the XCM message could be delivered1847       * by the network, and if the receiving chain would handle1848       * messages correctly.1849       **/1850      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]>;1851      /**1852       * Transfer several currencies specifying the item to be used as fee1853       * 1854       * `dest_weight_limit` is the weight for XCM execution on the dest1855       * chain, and it would be charged from the transferred assets. If set1856       * below requirements, the execution may fail and assets wouldn't be1857       * received.1858       * 1859       * `fee_item` is index of the currencies tuple that we want to use for1860       * payment1861       * 1862       * It's a no-op if any error on local XCM execution or message sending.1863       * Note sending assets out per se doesn't guarantee they would be1864       * received. Receiving depends on if the XCM message could be delivered1865       * by the network, and if the receiving chain would handle1866       * messages correctly.1867       **/1868      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]>;1869      /**1870       * Transfer native currencies specifying the fee and amount as1871       * separate.1872       * 1873       * `dest_weight_limit` is the weight for XCM execution on the dest1874       * chain, and it would be charged from the transferred assets. If set1875       * below requirements, the execution may fail and assets wouldn't be1876       * received.1877       * 1878       * `fee` is the amount to be spent to pay for execution in destination1879       * chain. Both fee and amount will be subtracted form the callers1880       * balance.1881       * 1882       * If `fee` is not high enough to cover for the execution costs in the1883       * destination chain, then the assets will be trapped in the1884       * destination chain1885       * 1886       * It's a no-op if any error on local XCM execution or message sending.1887       * Note sending assets out per se doesn't guarantee they would be1888       * received. Receiving depends on if the XCM message could be delivered1889       * by the network, and if the receiving chain would handle1890       * messages correctly.1891       **/1892      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]>;1893      /**1894       * Generic tx1895       **/1896      [key: string]: SubmittableExtrinsicFunction<ApiType>;1897    };1898  } // AugmentedSubmittables1899} // declare module