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

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';11<<<<<<< HEAD12import type { AccountId32, Call, H160, H256, MultiAddress, Permill } from '@polkadot/types/interfaces/runtime';13=======14<<<<<<< HEAD15import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill } from '@polkadot/types/interfaces/runtime';16>>>>>>> chore:  regenerate types17import 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';18=======19import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill, Weight } from '@polkadot/types/interfaces/runtime';20<<<<<<< HEAD21import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumLog, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';22=======23import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';24>>>>>>> chore:  regenerate types25>>>>>>> chore:  regenerate types2627export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;28export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;29export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;3031declare module '@polkadot/api-base/types/submittable' {32  interface AugmentedSubmittables<ApiType extends ApiTypes> {33    appPromotion: {34      /**35       * Recalculates interest for the specified number of stakers.36       * If all stakers are not recalculated, the next call of the extrinsic37       * will continue the recalculation, from those stakers for whom this38       * was not perform in last call.39       * 40       * # Permissions41       * 42       * * Pallet admin43       * 44       * # Arguments45       * 46       * * `stakers_number`: the number of stakers for which recalculation will be performed47       **/48      payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;49      /**50       * Sets an address as the the admin.51       * 52       * # Permissions53       * 54       * * Sudo55       * 56       * # Arguments57       * 58       * * `admin`: account of the new admin.59       **/60      setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;61      /**62       * Sets the pallet to be the sponsor for the collection.63       * 64       * # Permissions65       * 66       * * Pallet admin67       * 68       * # Arguments69       * 70       * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`71       **/72      sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;73      /**74       * Sets the pallet to be the sponsor for the contract.75       * 76       * # Permissions77       * 78       * * Pallet admin79       * 80       * # Arguments81       * 82       * * `contract_id`: the contract address that will be sponsored by `pallet_id`83       **/84      sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;85      /**86       * Stakes the amount of native tokens.87       * Sets `amount` to the locked state.88       * The maximum number of stakes for a staker is 10.89       * 90       * # Arguments91       * 92       * * `amount`: in native tokens.93       **/94      stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;95      /**96       * Removes the pallet as the sponsor for the collection.97       * Returns [`NoPermission`][`Error::NoPermission`]98       * if the pallet wasn't the sponsor.99       * 100       * # Permissions101       * 102       * * Pallet admin103       * 104       * # Arguments105       * 106       * * `collection_id`: ID of the collection that is sponsored by `pallet_id`107       **/108      stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;109      /**110       * Removes the pallet as the sponsor for the contract.111       * Returns [`NoPermission`][`Error::NoPermission`]112       * if the pallet wasn't the sponsor.113       * 114       * # Permissions115       * 116       * * Pallet admin117       * 118       * # Arguments119       * 120       * * `contract_id`: the contract address that is sponsored by `pallet_id`121       **/122      stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;123      /**124       * Unstakes all stakes.125       * Moves the sum of all stakes to the `reserved` state.126       * After the end of `PendingInterval` this sum becomes completely127       * free for further use.128       **/129      unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;130      /**131       * Generic tx132       **/133      [key: string]: SubmittableExtrinsicFunction<ApiType>;134    };135    balances: {136      /**137       * Exactly as `transfer`, except the origin must be root and the source account may be138       * specified.139       * # <weight>140       * - Same as transfer, but additional read and write because the source account is not141       * assumed to be in the overlay.142       * # </weight>143       **/144      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>]>;145      /**146       * Unreserve some balance from a user by force.147       * 148       * Can only be called by ROOT.149       **/150      forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;151      /**152       * Set the balances of a given account.153       * 154       * This will alter `FreeBalance` and `ReservedBalance` in storage. it will155       * also alter the total issuance of the system (`TotalIssuance`) appropriately.156       * If the new free or reserved balance is below the existential deposit,157       * it will reset the account nonce (`frame_system::AccountNonce`).158       * 159       * The dispatch origin for this call is `root`.160       **/161      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>]>;162      /**163       * Transfer some liquid free balance to another account.164       * 165       * `transfer` will set the `FreeBalance` of the sender and receiver.166       * If the sender's account is below the existential deposit as a result167       * of the transfer, the account will be reaped.168       * 169       * The dispatch origin for this call must be `Signed` by the transactor.170       * 171       * # <weight>172       * - Dependent on arguments but not critical, given proper implementations for input config173       * types. See related functions below.174       * - It contains a limited number of reads and writes internally and no complex175       * computation.176       * 177       * Related functions:178       * 179       * - `ensure_can_withdraw` is always called internally but has a bounded complexity.180       * - Transferring balances to accounts that did not exist before will cause181       * `T::OnNewAccount::on_new_account` to be called.182       * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.183       * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check184       * that the transfer will not kill the origin account.185       * ---------------------------------186       * - Origin account is already in memory, so no DB operations for them.187       * # </weight>188       **/189      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>]>;190      /**191       * Transfer the entire transferable balance from the caller account.192       * 193       * NOTE: This function only attempts to transfer _transferable_ balances. This means that194       * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be195       * transferred by this function. To ensure that this function results in a killed account,196       * you might need to prepare the account by removing any reference counters, storage197       * deposits, etc...198       * 199       * The dispatch origin of this call must be Signed.200       * 201       * - `dest`: The recipient of the transfer.202       * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all203       * of the funds the account has, causing the sender account to be killed (false), or204       * transfer everything except at least the existential deposit, which will guarantee to205       * keep the sender account alive (true). # <weight>206       * - O(1). Just like transfer, but reading the user's transferable balance first.207       * #</weight>208       **/209      transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;210      /**211       * Same as the [`transfer`] call, but with a check that the transfer will not kill the212       * origin account.213       * 214       * 99% of the time you want [`transfer`] instead.215       * 216       * [`transfer`]: struct.Pallet.html#method.transfer217       **/218      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>]>;219      /**220       * Generic tx221       **/222      [key: string]: SubmittableExtrinsicFunction<ApiType>;223    };224    charging: {225      /**226       * Generic tx227       **/228      [key: string]: SubmittableExtrinsicFunction<ApiType>;229    };230    configuration: {231      setAppPromotionConfigurationOverride: AugmentedSubmittable<(configuration: PalletConfigurationAppPromotionConfiguration | { recalculationInterval?: any; pendingInterval?: any; intervalIncome?: any; maxStakersPerCalculation?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletConfigurationAppPromotionConfiguration]>;232      setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;233      setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;234      setXcmAllowedLocations: AugmentedSubmittable<(locations: Option<Vec<XcmV1MultiLocation>> | null | Uint8Array | Vec<XcmV1MultiLocation> | (XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<Vec<XcmV1MultiLocation>>]>;235      /**236       * Generic tx237       **/238      [key: string]: SubmittableExtrinsicFunction<ApiType>;239    };240    cumulusXcm: {241      /**242       * Generic tx243       **/244      [key: string]: SubmittableExtrinsicFunction<ApiType>;245    };246    dmpQueue: {247      /**248       * Service a single overweight message.249       * 250       * - `origin`: Must pass `ExecuteOverweightOrigin`.251       * - `index`: The index of the overweight message to service.252       * - `weight_limit`: The amount of weight that message execution may take.253       * 254       * Errors:255       * - `Unknown`: Message of `index` is unknown.256       * - `OverLimit`: Message execution may use greater than `weight_limit`.257       * 258       * Events:259       * - `OverweightServiced`: On success.260       **/261      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;262      /**263       * Generic tx264       **/265      [key: string]: SubmittableExtrinsicFunction<ApiType>;266    };267    ethereum: {268      /**269       * Transact an Ethereum transaction.270       **/271      transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;272      /**273       * Generic tx274       **/275      [key: string]: SubmittableExtrinsicFunction<ApiType>;276    };277    evm: {278      /**279       * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.280       **/281      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>]>>]>;282      /**283       * Issue an EVM create operation. This is similar to a contract creation transaction in284       * Ethereum.285       **/286      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>]>>]>;287      /**288       * Issue an EVM create2 operation.289       **/290      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>]>>]>;291      /**292       * Withdraw balance from EVM into currency/balances pallet.293       **/294      withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;295      /**296       * Generic tx297       **/298      [key: string]: SubmittableExtrinsicFunction<ApiType>;299    };300    evmMigration: {301      /**302       * Start contract migration, inserts contract stub at target address,303       * and marks account as pending, allowing to insert storage304       **/305      begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;306      /**307       * Finish contract migration, allows it to be called.308       * It is not possible to alter contract storage via [`Self::set_data`]309       * after this call.310       **/311      finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;312      /**313       * Create ethereum events attached to the fake transaction314       **/315      insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;316      /**317       * Create substrate events318       **/319      insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;320      /**321       * Insert items into contract storage, this method can be called322       * multiple times323       **/324      setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;325      /**326       * Generic tx327       **/328      [key: string]: SubmittableExtrinsicFunction<ApiType>;329    };330    foreignAssets: {331      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]>;332      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]>;333      /**334       * Generic tx335       **/336      [key: string]: SubmittableExtrinsicFunction<ApiType>;337    };338    inflation: {339      /**340       * This method sets the inflation start date. Can be only called once.341       * Inflation start block can be backdated and will catch up. The method will create Treasury342       * account if it does not exist and perform the first inflation deposit.343       * 344       * # Permissions345       * 346       * * Root347       * 348       * # Arguments349       * 350       * * inflation_start_relay_block: The relay chain block at which inflation should start351       **/352      startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;353      /**354       * Generic tx355       **/356      [key: string]: SubmittableExtrinsicFunction<ApiType>;357    };358    maintenance: {359      disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;360      enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;361      /**362       * Generic tx363       **/364      [key: string]: SubmittableExtrinsicFunction<ApiType>;365    };366    parachainSystem: {367      authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;368      enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;369      /**370       * Set the current validation data.371       * 372       * This should be invoked exactly once per block. It will panic at the finalization373       * phase if the call was not invoked.374       * 375       * The dispatch origin for this call must be `Inherent`376       * 377       * As a side effect, this function upgrades the current validation function378       * if the appropriate time has come.379       **/380      setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;381      sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;382      /**383       * Generic tx384       **/385      [key: string]: SubmittableExtrinsicFunction<ApiType>;386    };387    polkadotXcm: {388      /**389       * Execute an XCM message from a local, signed, origin.390       * 391       * An event is deposited indicating whether `msg` could be executed completely or only392       * partially.393       * 394       * No more than `max_weight` will be used in its attempted execution. If this is less than the395       * maximum amount of weight that the message could take to be executed, then no execution396       * attempt will be made.397       * 398       * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully399       * to completion; only that *some* of it was executed.400       **/401      execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;402      /**403       * Set a safe XCM version (the version that XCM should be encoded with if the most recent404       * version a destination can accept is unknown).405       * 406       * - `origin`: Must be Root.407       * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.408       **/409      forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;410      /**411       * Ask a location to notify us regarding their XCM version and any changes to it.412       * 413       * - `origin`: Must be Root.414       * - `location`: The location to which we should subscribe for XCM version notifications.415       **/416      forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;417      /**418       * Require that a particular destination should no longer notify us regarding any XCM419       * version changes.420       * 421       * - `origin`: Must be Root.422       * - `location`: The location to which we are currently subscribed for XCM version423       * notifications which we no longer desire.424       **/425      forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;426      /**427       * Extoll that a particular destination can be communicated with through a particular428       * version of XCM.429       * 430       * - `origin`: Must be Root.431       * - `location`: The destination that is being described.432       * - `xcm_version`: The latest version of XCM that `location` supports.433       **/434      forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;435      /**436       * Transfer some assets from the local chain to the sovereign account of a destination437       * chain and forward a notification XCM.438       * 439       * Fee payment on the destination side is made from the asset in the `assets` vector of440       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight441       * is needed than `weight_limit`, then the operation will fail and the assets send may be442       * at risk.443       * 444       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.445       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send446       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.447       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be448       * an `AccountId32` value.449       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the450       * `dest` side.451       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay452       * fees.453       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.454       **/455      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]>;456      /**457       * Teleport some assets from the local chain to some destination chain.458       * 459       * Fee payment on the destination side is made from the asset in the `assets` vector of460       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight461       * is needed than `weight_limit`, then the operation will fail and the assets send may be462       * at risk.463       * 464       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.465       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send466       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.467       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be468       * an `AccountId32` value.469       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the470       * `dest` side. May not be empty.471       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay472       * fees.473       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.474       **/475      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]>;476      /**477       * Transfer some assets from the local chain to the sovereign account of a destination478       * chain and forward a notification XCM.479       * 480       * Fee payment on the destination side is made from the asset in the `assets` vector of481       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,482       * with all fees taken as needed from the asset.483       * 484       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.485       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send486       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.487       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be488       * an `AccountId32` value.489       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the490       * `dest` side.491       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay492       * fees.493       **/494      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]>;495      send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;496      /**497       * Teleport some assets from the local chain to some destination chain.498       * 499       * Fee payment on the destination side is made from the asset in the `assets` vector of500       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,501       * with all fees taken as needed from the asset.502       * 503       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.504       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send505       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.506       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be507       * an `AccountId32` value.508       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the509       * `dest` side. May not be empty.510       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay511       * fees.512       **/513      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]>;514      /**515       * Generic tx516       **/517      [key: string]: SubmittableExtrinsicFunction<ApiType>;518    };519    rmrkCore: {520      /**521       * Accept an NFT sent from another account to self or an owned NFT.522       * 523       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.524       * 525       * # Permissions:526       * - Token-owner-to-be527       * 528       * # Arguments:529       * - `origin`: sender of the transaction530       * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.531       * - `rmrk_nft_id`: ID of the NFT to be accepted.532       * - `new_owner`: Either the sender's account ID or a sender-owned NFT,533       * whichever the accepted NFT was sent to.534       **/535      acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;536      /**537       * Accept the addition of a newly created pending resource to an existing NFT.538       * 539       * This transaction is needed when a resource is created and assigned to an NFT540       * by a non-owner, i.e. the collection issuer, with one of the541       * [`add_...` transactions](Pallet::add_basic_resource).542       * 543       * # Permissions:544       * - Token owner545       * 546       * # Arguments:547       * - `origin`: sender of the transaction548       * - `rmrk_collection_id`: RMRK collection ID of the NFT.549       * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.550       * - `resource_id`: ID of the newly created pending resource.551       * accept the addition of a new resource to an existing NFT552       **/553      acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;554      /**555       * Accept the removal of a removal-pending resource from an NFT.556       * 557       * This transaction is needed when a non-owner, i.e. the collection issuer,558       * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.559       * 560       * # Permissions:561       * - Token owner562       * 563       * # Arguments:564       * - `origin`: sender of the transaction565       * - `rmrk_collection_id`: RMRK collection ID of the NFT.566       * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.567       * - `resource_id`: ID of the removal-pending resource.568       **/569      acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;570      /**571       * Create and set/propose a basic resource for an NFT.572       * 573       * A basic resource is the simplest, lacking a Base and anything that comes with it.574       * See RMRK docs for more information and examples.575       * 576       * # Permissions:577       * - Collection issuer - if not the token owner, adding the resource will warrant578       * the owner's [acceptance](Pallet::accept_resource).579       * 580       * # Arguments:581       * - `origin`: sender of the transaction582       * - `rmrk_collection_id`: RMRK collection ID of the NFT.583       * - `nft_id`: ID of the NFT to assign a resource to.584       * - `resource`: Data of the resource to be created.585       **/586      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]>;587      /**588       * Create and set/propose a composable resource for an NFT.589       * 590       * A composable resource links to a Base and has a subset of its Parts it is composed of.591       * See RMRK docs for more information and examples.592       * 593       * # Permissions:594       * - Collection issuer - if not the token owner, adding the resource will warrant595       * the owner's [acceptance](Pallet::accept_resource).596       * 597       * # Arguments:598       * - `origin`: sender of the transaction599       * - `rmrk_collection_id`: RMRK collection ID of the NFT.600       * - `nft_id`: ID of the NFT to assign a resource to.601       * - `resource`: Data of the resource to be created.602       **/603      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]>;604      /**605       * Create and set/propose a slot resource for an NFT.606       * 607       * A slot resource links to a Base and a slot ID in it which it can fit into.608       * See RMRK docs for more information and examples.609       * 610       * # Permissions:611       * - Collection issuer - if not the token owner, adding the resource will warrant612       * the owner's [acceptance](Pallet::accept_resource).613       * 614       * # Arguments:615       * - `origin`: sender of the transaction616       * - `rmrk_collection_id`: RMRK collection ID of the NFT.617       * - `nft_id`: ID of the NFT to assign a resource to.618       * - `resource`: Data of the resource to be created.619       **/620      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]>;621      /**622       * Burn an NFT, destroying it and its nested tokens up to the specified limit.623       * If the burning budget is exceeded, the transaction is reverted.624       * 625       * This is the way to burn a nested token as well.626       * 627       * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).628       * 629       * # Permissions:630       * * Token owner631       * 632       * # Arguments:633       * - `origin`: sender of the transaction634       * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.635       * - `nft_id`: ID of the NFT to be destroyed.636       * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction637       * is reverted if there are more tokens to burn in the nesting tree than this number.638       * This is primarily a mechanism of transaction weight control.639       **/640      burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;641      /**642       * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).643       * 644       * # Permissions:645       * * Collection issuer646       * 647       * # Arguments:648       * - `origin`: sender of the transaction649       * - `collection_id`: RMRK collection ID to change the issuer of.650       * - `new_issuer`: Collection's new issuer.651       **/652      changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;653      /**654       * Create a new collection of NFTs.655       * 656       * # Permissions:657       * * Anyone - will be assigned as the issuer of the collection.658       * 659       * # Arguments:660       * - `origin`: sender of the transaction661       * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.662       * - `max`: Optional maximum number of tokens.663       * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.664       * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.665       **/666      createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;667      /**668       * Destroy a collection.669       * 670       * Only empty collections can be destroyed. If it has any tokens, they must be burned first.671       * 672       * # Permissions:673       * * Collection issuer674       * 675       * # Arguments:676       * - `origin`: sender of the transaction677       * - `collection_id`: RMRK ID of the collection to destroy.678       **/679      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;680      /**681       * "Lock" the collection and prevent new token creation. Cannot be undone.682       * 683       * # Permissions:684       * * Collection issuer685       * 686       * # Arguments:687       * - `origin`: sender of the transaction688       * - `collection_id`: RMRK ID of the collection to lock.689       **/690      lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;691      /**692       * Mint an NFT in a specified collection.693       * 694       * # Permissions:695       * * Collection issuer696       * 697       * # Arguments:698       * - `origin`: sender of the transaction699       * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).700       * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.701       * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.702       * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.703       * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.704       * - `transferable`: Can this NFT be transferred? Cannot be changed.705       * - `resources`: Resource data to be added to the NFT immediately after minting.706       **/707      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>>]>;708      /**709       * Reject an NFT sent from another account to self or owned NFT.710       * The NFT in question will not be sent back and burnt instead.711       * 712       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.713       * 714       * # Permissions:715       * - Token-owner-to-be-not716       * 717       * # Arguments:718       * - `origin`: sender of the transaction719       * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.720       * - `rmrk_nft_id`: ID of the NFT to be rejected.721       **/722      rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;723      /**724       * Remove and erase a resource from an NFT.725       * 726       * If the sender does not own the NFT, then it will be pending confirmation,727       * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.728       * 729       * # Permissions730       * - Collection issuer731       * 732       * # Arguments733       * - `origin`: sender of the transaction734       * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.735       * - `nft_id`: ID of the NFT with a resource to be removed.736       * - `resource_id`: ID of the resource to be removed.737       **/738      removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;739      /**740       * Transfer an NFT from an account/NFT A to another account/NFT B.741       * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].742       * 743       * If the target owner is an NFT owned by another account, then the NFT will enter744       * the pending state and will have to be accepted by the other account.745       * 746       * # Permissions:747       * - Token owner748       * 749       * # Arguments:750       * - `origin`: sender of the transaction751       * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.752       * - `rmrk_nft_id`: ID of the NFT to be transferred.753       * - `new_owner`: New owner of the nft which can be either an account or a NFT.754       **/755      send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;756      /**757       * Set a different order of resource priorities for an NFT. Priorities can be used,758       * for example, for order of rendering.759       * 760       * Note that the priorities are not updated automatically, and are an empty vector761       * by default. There is no pre-set definition for the order to be particular,762       * it can be interpreted arbitrarily use-case by use-case.763       * 764       * # Permissions:765       * - Token owner766       * 767       * # Arguments:768       * - `origin`: sender of the transaction769       * - `rmrk_collection_id`: RMRK collection ID of the NFT.770       * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.771       * - `priorities`: Ordered vector of resource IDs.772       **/773      setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;774      /**775       * Add or edit a custom user property, a key-value pair, describing the metadata776       * of a token or a collection, on either one of these.777       * 778       * Note that in this proxy implementation many details regarding RMRK are stored779       * as scoped properties prefixed with "rmrk:", normally inaccessible780       * to external transactions and RPCs.781       * 782       * # Permissions:783       * - Collection issuer - in case of collection property784       * - Token owner - in case of NFT property785       * 786       * # Arguments:787       * - `origin`: sender of the transaction788       * - `rmrk_collection_id`: RMRK collection ID.789       * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.790       * - `key`: Key of the custom property to be referenced by.791       * - `value`: Value of the custom property to be stored.792       **/793      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]>;794      /**795       * Generic tx796       **/797      [key: string]: SubmittableExtrinsicFunction<ApiType>;798    };799    rmrkEquip: {800      /**801       * Create a new Base.802       * 803       * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)804       * 805       * # Permissions806       * - Anyone - will be assigned as the issuer of the Base.807       * 808       * # Arguments:809       * - `origin`: Caller, will be assigned as the issuer of the Base810       * - `base_type`: Arbitrary media type, e.g. "svg".811       * - `symbol`: Arbitrary client-chosen symbol.812       * - `parts`: Array of Fixed and Slot Parts composing the Base,813       * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).814       **/815      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>]>;816      /**817       * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.818       * 819       * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).820       * 821       * # Permissions:822       * - Base issuer823       * 824       * # Arguments:825       * - `origin`: sender of the transaction826       * - `base_id`: Base containing the Slot Part to be updated.827       * - `slot_id`: Slot Part whose Equippable List is being updated .828       * - `equippables`: List of equippables that will override the current Equippables list.829       **/830      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]>;831      /**832       * Add a Theme to a Base.833       * A Theme named "default" is required prior to adding other Themes.834       * 835       * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).836       * 837       * # Permissions:838       * - Base issuer839       * 840       * # Arguments:841       * - `origin`: sender of the transaction842       * - `base_id`: Base ID containing the Theme to be updated.843       * - `theme`: Theme to add to the Base.  A Theme has a name and properties, which are an844       * array of [key, value, inherit].845       * - `key`: Arbitrary BoundedString, defined by client.846       * - `value`: Arbitrary BoundedString, defined by client.847       * - `inherit`: Optional bool.848       **/849      themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;850      /**851       * Generic tx852       **/853      [key: string]: SubmittableExtrinsicFunction<ApiType>;854    };855    structure: {856      /**857       * Generic tx858       **/859      [key: string]: SubmittableExtrinsicFunction<ApiType>;860    };861    sudo: {862      /**863       * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo864       * key.865       * 866       * The dispatch origin for this call must be _Signed_.867       * 868       * # <weight>869       * - O(1).870       * - Limited storage reads.871       * - One DB change.872       * # </weight>873       **/874      setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;875      /**876       * Authenticates the sudo key and dispatches a function call with `Root` origin.877       * 878       * The dispatch origin for this call must be _Signed_.879       * 880       * # <weight>881       * - O(1).882       * - Limited storage reads.883       * - One DB write (event).884       * - Weight of derivative `call` execution + 10,000.885       * # </weight>886       **/887      sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;888      /**889       * Authenticates the sudo key and dispatches a function call with `Signed` origin from890       * a given account.891       * 892       * The dispatch origin for this call must be _Signed_.893       * 894       * # <weight>895       * - O(1).896       * - Limited storage reads.897       * - One DB write (event).898       * - Weight of derivative `call` execution + 10,000.899       * # </weight>900       **/901      sudoAs: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Call]>;902      /**903       * Authenticates the sudo key and dispatches a function call with `Root` origin.904       * This function does not check the weight of the call, and instead allows the905       * Sudo user to specify the weight of the call.906       * 907       * The dispatch origin for this call must be _Signed_.908       * 909       * # <weight>910       * - O(1).911       * - The weight of this call is defined by the caller.912       * # </weight>913       **/914      sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;915      /**916       * Generic tx917       **/918      [key: string]: SubmittableExtrinsicFunction<ApiType>;919    };920    system: {921      /**922       * Kill all storage items with a key that starts with the given prefix.923       * 924       * **NOTE:** We rely on the Root origin to provide us the number of subkeys under925       * the prefix we are removing to accurately calculate the weight of this function.926       **/927      killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;928      /**929       * Kill some items from storage.930       **/931      killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;932      /**933       * Make some on-chain remark.934       * 935       * # <weight>936       * - `O(1)`937       * # </weight>938       **/939      remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;940      /**941       * Make some on-chain remark and emit event.942       **/943      remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;944      /**945       * Set the new runtime code.946       * 947       * # <weight>948       * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`949       * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is950       * expensive).951       * - 1 storage write (codec `O(C)`).952       * - 1 digest item.953       * - 1 event.954       * The weight of this function is dependent on the runtime, but generally this is very955       * expensive. We will treat this as a full block.956       * # </weight>957       **/958      setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;959      /**960       * Set the new runtime code without doing any checks of the given `code`.961       * 962       * # <weight>963       * - `O(C)` where `C` length of `code`964       * - 1 storage write (codec `O(C)`).965       * - 1 digest item.966       * - 1 event.967       * The weight of this function is dependent on the runtime. We will treat this as a full968       * block. # </weight>969       **/970      setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;971      /**972       * Set the number of pages in the WebAssembly environment's heap.973       **/974      setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;975      /**976       * Set some items of storage.977       **/978      setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;979      /**980       * Generic tx981       **/982      [key: string]: SubmittableExtrinsicFunction<ApiType>;983    };984    testUtils: {985      batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;986      enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;987      incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;988      justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;989      setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;990      setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;991      /**992       * Generic tx993       **/994      [key: string]: SubmittableExtrinsicFunction<ApiType>;995    };996    timestamp: {997      /**998       * Set the current time.999       * 1000       * This call should be invoked exactly once per block. It will panic at the finalization1001       * phase, if this call hasn't been invoked by that time.1002       * 1003       * The timestamp should be greater than the previous one by the amount specified by1004       * `MinimumPeriod`.1005       * 1006       * The dispatch origin for this call must be `Inherent`.1007       * 1008       * # <weight>1009       * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1010       * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1011       * `on_finalize`)1012       * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1013       * # </weight>1014       **/1015      set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1016      /**1017       * Generic tx1018       **/1019      [key: string]: SubmittableExtrinsicFunction<ApiType>;1020    };1021    tokens: {1022      /**1023       * Exactly as `transfer`, except the origin must be root and the source1024       * account may be specified.1025       * 1026       * The dispatch origin for this call must be _Root_.1027       * 1028       * - `source`: The sender of the transfer.1029       * - `dest`: The recipient of the transfer.1030       * - `currency_id`: currency type.1031       * - `amount`: free balance amount to tranfer.1032       **/1033      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>]>;1034      /**1035       * Set the balances of a given account.1036       * 1037       * This will alter `FreeBalance` and `ReservedBalance` in storage. it1038       * will also decrease the total issuance of the system1039       * (`TotalIssuance`). If the new free or reserved balance is below the1040       * existential deposit, it will reap the `AccountInfo`.1041       * 1042       * The dispatch origin for this call is `root`.1043       **/1044      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>]>;1045      /**1046       * Transfer some liquid free balance to another account.1047       * 1048       * `transfer` will set the `FreeBalance` of the sender and receiver.1049       * It will decrease the total issuance of the system by the1050       * `TransferFee`. If the sender's account is below the existential1051       * deposit as a result of the transfer, the account will be reaped.1052       * 1053       * The dispatch origin for this call must be `Signed` by the1054       * transactor.1055       * 1056       * - `dest`: The recipient of the transfer.1057       * - `currency_id`: currency type.1058       * - `amount`: free balance amount to tranfer.1059       **/1060      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>]>;1061      /**1062       * Transfer all remaining balance to the given account.1063       * 1064       * NOTE: This function only attempts to transfer _transferable_1065       * balances. This means that any locked, reserved, or existential1066       * deposits (when `keep_alive` is `true`), will not be transferred by1067       * this function. To ensure that this function results in a killed1068       * account, you might need to prepare the account by removing any1069       * reference counters, storage deposits, etc...1070       * 1071       * The dispatch origin for this call must be `Signed` by the1072       * transactor.1073       * 1074       * - `dest`: The recipient of the transfer.1075       * - `currency_id`: currency type.1076       * - `keep_alive`: A boolean to determine if the `transfer_all`1077       * operation should send all of the funds the account has, causing1078       * the sender account to be killed (false), or transfer everything1079       * except at least the existential deposit, which will guarantee to1080       * keep the sender account alive (true).1081       **/1082      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]>;1083      /**1084       * Same as the [`transfer`] call, but with a check that the transfer1085       * will not kill the origin account.1086       * 1087       * 99% of the time you want [`transfer`] instead.1088       * 1089       * The dispatch origin for this call must be `Signed` by the1090       * transactor.1091       * 1092       * - `dest`: The recipient of the transfer.1093       * - `currency_id`: currency type.1094       * - `amount`: free balance amount to tranfer.1095       **/1096      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>]>;1097      /**1098       * Generic tx1099       **/1100      [key: string]: SubmittableExtrinsicFunction<ApiType>;1101    };1102    treasury: {1103      /**1104       * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1105       * and the original deposit will be returned.1106       * 1107       * May only be called from `T::ApproveOrigin`.1108       * 1109       * # <weight>1110       * - Complexity: O(1).1111       * - DbReads: `Proposals`, `Approvals`1112       * - DbWrite: `Approvals`1113       * # </weight>1114       **/1115      approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1116      /**1117       * Put forward a suggestion for spending. A deposit proportional to the value1118       * is reserved and slashed if the proposal is rejected. It is returned once the1119       * proposal is awarded.1120       * 1121       * # <weight>1122       * - Complexity: O(1)1123       * - DbReads: `ProposalCount`, `origin account`1124       * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1125       * # </weight>1126       **/1127      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]>;1128      /**1129       * Reject a proposed spend. The original deposit will be slashed.1130       * 1131       * May only be called from `T::RejectOrigin`.1132       * 1133       * # <weight>1134       * - Complexity: O(1)1135       * - DbReads: `Proposals`, `rejected proposer account`1136       * - DbWrites: `Proposals`, `rejected proposer account`1137       * # </weight>1138       **/1139      rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1140      /**1141       * Force a previously approved proposal to be removed from the approval queue.1142       * The original deposit will no longer be returned.1143       * 1144       * May only be called from `T::RejectOrigin`.1145       * - `proposal_id`: The index of a proposal1146       * 1147       * # <weight>1148       * - Complexity: O(A) where `A` is the number of approvals1149       * - Db reads and writes: `Approvals`1150       * # </weight>1151       * 1152       * Errors:1153       * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1154       * i.e., the proposal has not been approved. This could also mean the proposal does not1155       * exist altogether, thus there is no way it would have been approved in the first place.1156       **/1157      removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1158      /**1159       * Propose and approve a spend of treasury funds.1160       * 1161       * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1162       * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1163       * - `beneficiary`: The destination account for the transfer.1164       * 1165       * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1166       * beneficiary.1167       **/1168      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]>;1169      /**1170       * Generic tx1171       **/1172      [key: string]: SubmittableExtrinsicFunction<ApiType>;1173    };1174    unique: {1175      /**1176       * Add an admin to a collection.1177       * 1178       * NFT Collection can be controlled by multiple admin addresses1179       * (some which can also be servers, for example). Admins can issue1180       * and burn NFTs, as well as add and remove other admins,1181       * but cannot change NFT or Collection ownership.1182       * 1183       * # Permissions1184       * 1185       * * Collection owner1186       * * Collection admin1187       * 1188       * # Arguments1189       * 1190       * * `collection_id`: ID of the Collection to add an admin for.1191       * * `new_admin`: Address of new admin to add.1192       **/1193      addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1194      /**1195       * Add an address to allow list.1196       * 1197       * # Permissions1198       * 1199       * * Collection owner1200       * * Collection admin1201       * 1202       * # Arguments1203       * 1204       * * `collection_id`: ID of the modified collection.1205       * * `address`: ID of the address to be added to the allowlist.1206       **/1207      addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1208      /**1209       * Allow a non-permissioned address to transfer or burn an item.1210       * 1211       * # Permissions1212       * 1213       * * Collection owner1214       * * Collection admin1215       * * Current item owner1216       * 1217       * # Arguments1218       * 1219       * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1220       * * `collection_id`: ID of the collection the item belongs to.1221       * * `item_id`: ID of the item transactions on which are now approved.1222       * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1223       * Set to 0 to revoke the approval.1224       **/1225      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]>;1226      /**1227       * Destroy a token on behalf of the owner as a non-owner account.1228       * 1229       * See also: [`approve`][`Pallet::approve`].1230       * 1231       * After this method executes, one approval is removed from the total so that1232       * the approved address will not be able to transfer this item again from this owner.1233       * 1234       * # Permissions1235       * 1236       * * Collection owner1237       * * Collection admin1238       * * Current token owner1239       * * Address approved by current item owner1240       * 1241       * # Arguments1242       * 1243       * * `from`: The owner of the burning item.1244       * * `collection_id`: ID of the collection to which the item belongs.1245       * * `item_id`: ID of item to burn.1246       * * `value`: Number of pieces to burn.1247       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1248       * * Fungible Mode: The desired number of pieces to burn.1249       * * Re-Fungible Mode: The desired number of pieces to burn.1250       **/1251      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]>;1252      /**1253       * Destroy an item.1254       * 1255       * # Permissions1256       * 1257       * * Collection owner1258       * * Collection admin1259       * * Current item owner1260       * 1261       * # Arguments1262       * 1263       * * `collection_id`: ID of the collection to which the item belongs.1264       * * `item_id`: ID of item to burn.1265       * * `value`: Number of pieces of the item to destroy.1266       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1267       * * Fungible Mode: The desired number of pieces to burn.1268       * * Re-Fungible Mode: The desired number of pieces to burn.1269       **/1270      burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1271      /**1272       * Change the owner of the collection.1273       * 1274       * # Permissions1275       * 1276       * * Collection owner1277       * 1278       * # Arguments1279       * 1280       * * `collection_id`: ID of the modified collection.1281       * * `new_owner`: ID of the account that will become the owner.1282       **/1283      changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1284      /**1285       * Confirm own sponsorship of a collection, becoming the sponsor.1286       * 1287       * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1288       * Sponsor can pay the fees of a transaction instead of the sender,1289       * but only within specified limits.1290       * 1291       * # Permissions1292       * 1293       * * Sponsor-to-be1294       * 1295       * # Arguments1296       * 1297       * * `collection_id`: ID of the collection with the pending sponsor.1298       **/1299      confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1300      /**1301       * Create a collection of tokens.1302       * 1303       * Each Token may have multiple properties encoded as an array of bytes1304       * of certain length. The initial owner of the collection is set1305       * to the address that signed the transaction and can be changed later.1306       * 1307       * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1308       * 1309       * # Permissions1310       * 1311       * * Anyone - becomes the owner of the new collection.1312       * 1313       * # Arguments1314       * 1315       * * `collection_name`: Wide-character string with collection name1316       * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1317       * * `collection_description`: Wide-character string with collection description1318       * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1319       * * `token_prefix`: Byte string containing the token prefix to mark a collection1320       * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1321       * * `mode`: Type of items stored in the collection and type dependent data.1322       **/1323      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]>;1324      /**1325       * Create a collection with explicit parameters.1326       * 1327       * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1328       * 1329       * # Permissions1330       * 1331       * * Anyone - becomes the owner of the new collection.1332       * 1333       * # Arguments1334       * 1335       * * `data`: Explicit data of a collection used for its creation.1336       **/1337      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]>;1338      /**1339       * Mint an item within a collection.1340       * 1341       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1342       * 1343       * # Permissions1344       * 1345       * * Collection owner1346       * * Collection admin1347       * * Anyone if1348       * * Allow List is enabled, and1349       * * Address is added to allow list, and1350       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1351       * 1352       * # Arguments1353       * 1354       * * `collection_id`: ID of the collection to which an item would belong.1355       * * `owner`: Address of the initial owner of the item.1356       * * `data`: Token data describing the item to store on chain.1357       **/1358      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]>;1359      /**1360       * Create multiple items within a collection.1361       * 1362       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1363       * 1364       * # Permissions1365       * 1366       * * Collection owner1367       * * Collection admin1368       * * Anyone if1369       * * Allow List is enabled, and1370       * * Address is added to the allow list, and1371       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1372       * 1373       * # Arguments1374       * 1375       * * `collection_id`: ID of the collection to which the tokens would belong.1376       * * `owner`: Address of the initial owner of the tokens.1377       * * `items_data`: Vector of data describing each item to be created.1378       **/1379      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>]>;1380      /**1381       * Create multiple items within a collection with explicitly specified initial parameters.1382       * 1383       * # Permissions1384       * 1385       * * Collection owner1386       * * Collection admin1387       * * Anyone if1388       * * Allow List is enabled, and1389       * * Address is added to allow list, and1390       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1391       * 1392       * # Arguments1393       * 1394       * * `collection_id`: ID of the collection to which the tokens would belong.1395       * * `data`: Explicit item creation data.1396       **/1397      createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1398      /**1399       * Delete specified collection properties.1400       * 1401       * # Permissions1402       * 1403       * * Collection Owner1404       * * Collection Admin1405       * 1406       * # Arguments1407       * 1408       * * `collection_id`: ID of the modified collection.1409       * * `property_keys`: Vector of keys of the properties to be deleted.1410       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1411       **/1412      deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1413      /**1414       * Delete specified token properties. Currently properties only work with NFTs.1415       * 1416       * # Permissions1417       * 1418       * * Depends on collection's token property permissions and specified property mutability:1419       * * Collection owner1420       * * Collection admin1421       * * Token owner1422       * 1423       * # Arguments1424       * 1425       * * `collection_id`: ID of the collection to which the token belongs.1426       * * `token_id`: ID of the modified token.1427       * * `property_keys`: Vector of keys of the properties to be deleted.1428       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1429       **/1430      deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1431      /**1432       * Destroy a collection if no tokens exist within.1433       * 1434       * # Permissions1435       * 1436       * * Collection owner1437       * 1438       * # Arguments1439       * 1440       * * `collection_id`: Collection to destroy.1441       **/1442      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1443      /**1444       * Repairs a collection if the data was somehow corrupted.1445       * 1446       * # Arguments1447       * 1448       * * `collection_id`: ID of the collection to repair.1449       **/1450      forceRepairCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1451      /**1452       * Repairs a token if the data was somehow corrupted.1453       * 1454       * # Arguments1455       * 1456       * * `collection_id`: ID of the collection the item belongs to.1457       * * `item_id`: ID of the item.1458       **/1459      forceRepairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1460      /**1461       * Remove admin of a collection.1462       * 1463       * An admin address can remove itself. List of admins may become empty,1464       * in which case only Collection Owner will be able to add an Admin.1465       * 1466       * # Permissions1467       * 1468       * * Collection owner1469       * * Collection admin1470       * 1471       * # Arguments1472       * 1473       * * `collection_id`: ID of the collection to remove the admin for.1474       * * `account_id`: Address of the admin to remove.1475       **/1476      removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1477      /**1478       * Remove a collection's a sponsor, making everyone pay for their own transactions.1479       * 1480       * # Permissions1481       * 1482       * * Collection owner1483       * 1484       * # Arguments1485       * 1486       * * `collection_id`: ID of the collection with the sponsor to remove.1487       **/1488      removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1489      /**1490       * Remove an address from allow list.1491       * 1492       * # Permissions1493       * 1494       * * Collection owner1495       * * Collection admin1496       * 1497       * # Arguments1498       * 1499       * * `collection_id`: ID of the modified collection.1500       * * `address`: ID of the address to be removed from the allowlist.1501       **/1502      removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1503      /**1504       * Re-partition a refungible token, while owning all of its parts/pieces.1505       * 1506       * # Permissions1507       * 1508       * * Token owner (must own every part)1509       * 1510       * # Arguments1511       * 1512       * * `collection_id`: ID of the collection the RFT belongs to.1513       * * `token_id`: ID of the RFT.1514       * * `amount`: New number of parts/pieces into which the token shall be partitioned.1515       **/1516      repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1517      /**1518       * Sets or unsets the approval of a given operator.1519       * 1520       * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1521       * 1522       * # Arguments1523       * 1524       * * `owner`: Token owner1525       * * `operator`: Operator1526       * * `approve`: Should operator status be granted or revoked?1527       **/1528      setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1529      /**1530       * Set specific limits of a collection. Empty, or None fields mean chain default.1531       * 1532       * # Permissions1533       * 1534       * * Collection owner1535       * * Collection admin1536       * 1537       * # Arguments1538       * 1539       * * `collection_id`: ID of the modified collection.1540       * * `new_limit`: New limits of the collection. Fields that are not set (None)1541       * will not overwrite the old ones.1542       **/1543      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]>;1544      /**1545       * Set specific permissions of a collection. Empty, or None fields mean chain default.1546       * 1547       * # Permissions1548       * 1549       * * Collection owner1550       * * Collection admin1551       * 1552       * # Arguments1553       * 1554       * * `collection_id`: ID of the modified collection.1555       * * `new_permission`: New permissions of the collection. Fields that are not set (None)1556       * will not overwrite the old ones.1557       **/1558      setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1559      /**1560       * Add or change collection properties.1561       * 1562       * # Permissions1563       * 1564       * * Collection owner1565       * * Collection admin1566       * 1567       * # Arguments1568       * 1569       * * `collection_id`: ID of the modified collection.1570       * * `properties`: Vector of key-value pairs stored as the collection's metadata.1571       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1572       **/1573      setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1574      /**1575       * Set (invite) a new collection sponsor.1576       * 1577       * If successful, confirmation from the sponsor-to-be will be pending.1578       * 1579       * # Permissions1580       * 1581       * * Collection owner1582       * * Collection admin1583       * 1584       * # Arguments1585       * 1586       * * `collection_id`: ID of the modified collection.1587       * * `new_sponsor`: ID of the account of the sponsor-to-be.1588       **/1589      setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1590      /**1591       * Add or change token properties according to collection's permissions.1592       * Currently properties only work with NFTs.1593       * 1594       * # Permissions1595       * 1596       * * Depends on collection's token property permissions and specified property mutability:1597       * * Collection owner1598       * * Collection admin1599       * * Token owner1600       * 1601       * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1602       * 1603       * # Arguments1604       * 1605       * * `collection_id: ID of the collection to which the token belongs.1606       * * `token_id`: ID of the modified token.1607       * * `properties`: Vector of key-value pairs stored as the token's metadata.1608       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1609       **/1610      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>]>;1611      /**1612       * Add or change token property permissions of a collection.1613       * 1614       * Without a permission for a particular key, a property with that key1615       * cannot be created in a token.1616       * 1617       * # Permissions1618       * 1619       * * Collection owner1620       * * Collection admin1621       * 1622       * # Arguments1623       * 1624       * * `collection_id`: ID of the modified collection.1625       * * `property_permissions`: Vector of permissions for property keys.1626       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1627       **/1628      setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1629      /**1630       * Completely allow or disallow transfers for a particular collection.1631       * 1632       * # Permissions1633       * 1634       * * Collection owner1635       * 1636       * # Arguments1637       * 1638       * * `collection_id`: ID of the collection.1639       * * `value`: New value of the flag, are transfers allowed?1640       **/1641      setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1642      /**1643       * Change ownership of the token.1644       * 1645       * # Permissions1646       * 1647       * * Collection owner1648       * * Collection admin1649       * * Current token owner1650       * 1651       * # Arguments1652       * 1653       * * `recipient`: Address of token recipient.1654       * * `collection_id`: ID of the collection the item belongs to.1655       * * `item_id`: ID of the item.1656       * * Non-Fungible Mode: Required.1657       * * Fungible Mode: Ignored.1658       * * Re-Fungible Mode: Required.1659       * 1660       * * `value`: Amount to transfer.1661       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1662       * * Fungible Mode: The desired number of pieces to transfer.1663       * * Re-Fungible Mode: The desired number of pieces to transfer.1664       **/1665      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]>;1666      /**1667       * Change ownership of an item on behalf of the owner as a non-owner account.1668       * 1669       * See the [`approve`][`Pallet::approve`] method for additional information.1670       * 1671       * After this method executes, one approval is removed from the total so that1672       * the approved address will not be able to transfer this item again from this owner.1673       * 1674       * # Permissions1675       * 1676       * * Collection owner1677       * * Collection admin1678       * * Current item owner1679       * * Address approved by current item owner1680       * 1681       * # Arguments1682       * 1683       * * `from`: Address that currently owns the token.1684       * * `recipient`: Address of the new token-owner-to-be.1685       * * `collection_id`: ID of the collection the item.1686       * * `item_id`: ID of the item to be transferred.1687       * * `value`: Amount to transfer.1688       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1689       * * Fungible Mode: The desired number of pieces to transfer.1690       * * Re-Fungible Mode: The desired number of pieces to transfer.1691       **/1692      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]>;1693      /**1694       * Generic tx1695       **/1696      [key: string]: SubmittableExtrinsicFunction<ApiType>;1697    };1698    vesting: {1699      claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1700      claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1701      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>]>;1702      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]>;1703      /**1704       * Generic tx1705       **/1706      [key: string]: SubmittableExtrinsicFunction<ApiType>;1707    };1708    xcmpQueue: {1709      /**1710       * Resumes all XCM executions for the XCMP queue.1711       * 1712       * Note that this function doesn't change the status of the in/out bound channels.1713       * 1714       * - `origin`: Must pass `ControllerOrigin`.1715       **/1716      resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1717      /**1718       * Services a single overweight XCM.1719       * 1720       * - `origin`: Must pass `ExecuteOverweightOrigin`.1721       * - `index`: The index of the overweight XCM to service1722       * - `weight_limit`: The amount of weight that XCM execution may take.1723       * 1724       * Errors:1725       * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1726       * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1727       * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1728       * 1729       * Events:1730       * - `OverweightServiced`: On success.1731       **/1732      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1733      /**1734       * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1735       * 1736       * - `origin`: Must pass `ControllerOrigin`.1737       **/1738      suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1739      /**1740       * Overwrites the number of pages of messages which must be in the queue after which we drop any further1741       * messages from the channel.1742       * 1743       * - `origin`: Must pass `Root`.1744       * - `new`: Desired value for `QueueConfigData.drop_threshold`1745       **/1746      updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1747      /**1748       * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1749       * message sending may recommence after it has been suspended.1750       * 1751       * - `origin`: Must pass `Root`.1752       * - `new`: Desired value for `QueueConfigData.resume_threshold`1753       **/1754      updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1755      /**1756       * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1757       * suspend their sending.1758       * 1759       * - `origin`: Must pass `Root`.1760       * - `new`: Desired value for `QueueConfigData.suspend_value`1761       **/1762      updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1763      /**1764       * Overwrites the amount of remaining weight under which we stop processing messages.1765       * 1766       * - `origin`: Must pass `Root`.1767       * - `new`: Desired value for `QueueConfigData.threshold_weight`1768       **/1769      updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1770      /**1771       * Overwrites the speed to which the available weight approaches the maximum weight.1772       * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1773       * 1774       * - `origin`: Must pass `Root`.1775       * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1776       **/1777      updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1778      /**1779       * Overwrite the maximum amount of weight any individual message may consume.1780       * Messages above this weight go into the overweight queue and may only be serviced explicitly.1781       * 1782       * - `origin`: Must pass `Root`.1783       * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1784       **/1785      updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1786      /**1787       * Generic tx1788       **/1789      [key: string]: SubmittableExtrinsicFunction<ApiType>;1790    };1791    xTokens: {1792      /**1793       * Transfer native currencies.1794       * 1795       * `dest_weight_limit` is the weight for XCM execution on the dest1796       * chain, and it would be charged from the transferred assets. If set1797       * below requirements, the execution may fail and assets wouldn't be1798       * received.1799       * 1800       * It's a no-op if any error on local XCM execution or message sending.1801       * Note sending assets out per se doesn't guarantee they would be1802       * received. Receiving depends on if the XCM message could be delivered1803       * by the network, and if the receiving chain would handle1804       * messages correctly.1805       **/1806      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]>;1807      /**1808       * Transfer `MultiAsset`.1809       * 1810       * `dest_weight_limit` is the weight for XCM execution on the dest1811       * chain, and it would be charged from the transferred assets. If set1812       * below requirements, the execution may fail and assets wouldn't be1813       * received.1814       * 1815       * It's a no-op if any error on local XCM execution or message sending.1816       * Note sending assets out per se doesn't guarantee they would be1817       * received. Receiving depends on if the XCM message could be delivered1818       * by the network, and if the receiving chain would handle1819       * messages correctly.1820       **/1821      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]>;1822      /**1823       * Transfer several `MultiAsset` specifying the item to be used as fee1824       * 1825       * `dest_weight_limit` is the weight for XCM execution on the dest1826       * chain, and it would be charged from the transferred assets. If set1827       * below requirements, the execution may fail and assets wouldn't be1828       * received.1829       * 1830       * `fee_item` is index of the MultiAssets that we want to use for1831       * payment1832       * 1833       * It's a no-op if any error on local XCM execution or message sending.1834       * Note sending assets out per se doesn't guarantee they would be1835       * received. Receiving depends on if the XCM message could be delivered1836       * by the network, and if the receiving chain would handle1837       * messages correctly.1838       **/1839      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]>;1840      /**1841       * Transfer `MultiAsset` specifying the fee and amount as separate.1842       * 1843       * `dest_weight_limit` is the weight for XCM execution on the dest1844       * chain, and it would be charged from the transferred assets. If set1845       * below requirements, the execution may fail and assets wouldn't be1846       * received.1847       * 1848       * `fee` is the multiasset to be spent to pay for execution in1849       * destination chain. Both fee and amount will be subtracted form the1850       * callers balance For now we only accept fee and asset having the same1851       * `MultiLocation` id.1852       * 1853       * If `fee` is not high enough to cover for the execution costs in the1854       * destination chain, then the assets will be trapped in the1855       * destination chain1856       * 1857       * It's a no-op if any error on local XCM execution or message sending.1858       * Note sending assets out per se doesn't guarantee they would be1859       * received. Receiving depends on if the XCM message could be delivered1860       * by the network, and if the receiving chain would handle1861       * messages correctly.1862       **/1863      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]>;1864      /**1865       * Transfer several currencies specifying the item to be used as fee1866       * 1867       * `dest_weight_limit` is the weight for XCM execution on the dest1868       * chain, and it would be charged from the transferred assets. If set1869       * below requirements, the execution may fail and assets wouldn't be1870       * received.1871       * 1872       * `fee_item` is index of the currencies tuple that we want to use for1873       * payment1874       * 1875       * It's a no-op if any error on local XCM execution or message sending.1876       * Note sending assets out per se doesn't guarantee they would be1877       * received. Receiving depends on if the XCM message could be delivered1878       * by the network, and if the receiving chain would handle1879       * messages correctly.1880       **/1881      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]>;1882      /**1883       * Transfer native currencies specifying the fee and amount as1884       * separate.1885       * 1886       * `dest_weight_limit` is the weight for XCM execution on the dest1887       * chain, and it would be charged from the transferred assets. If set1888       * below requirements, the execution may fail and assets wouldn't be1889       * received.1890       * 1891       * `fee` is the amount to be spent to pay for execution in destination1892       * chain. Both fee and amount will be subtracted form the callers1893       * balance.1894       * 1895       * If `fee` is not high enough to cover for the execution costs in the1896       * destination chain, then the assets will be trapped in the1897       * destination chain1898       * 1899       * It's a no-op if any error on local XCM execution or message sending.1900       * Note sending assets out per se doesn't guarantee they would be1901       * received. Receiving depends on if the XCM message could be delivered1902       * by the network, and if the receiving chain would handle1903       * messages correctly.1904       **/1905      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]>;1906      /**1907       * Generic tx1908       **/1909      [key: string]: SubmittableExtrinsicFunction<ApiType>;1910    };1911  } // AugmentedSubmittables1912} // declare module