git.delta.rocks / unique-network / refs/commits / 081dbb6ae4fb

1// Auto-generated via `yarn polkadot-types-from-chain`, do not edit2/* eslint-disable */34// import type lookup before we augment - in some environments5// this is required to allow for ambient/previous definitions6import '@polkadot/api-base/types/submittable';78import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types';9import type { Bytes, Compact, Option, U256, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';10import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';11import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill } from '@polkadot/types/interfaces/runtime';12import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, FrameSupportScheduleMaybeHashed, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';1314export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;15export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;16export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;1718declare module '@polkadot/api-base/types/submittable' {19  interface AugmentedSubmittables<ApiType extends ApiTypes> {20    balances: {21      /**22       * Exactly as `transfer`, except the origin must be root and the source account may be23       * specified.24       * # <weight>25       * - Same as transfer, but additional read and write because the source account is not26       * assumed to be in the overlay.27       * # </weight>28       **/29      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>]>;30      /**31       * Unreserve some balance from a user by force.32       * 33       * Can only be called by ROOT.34       **/35      forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;36      /**37       * Set the balances of a given account.38       * 39       * This will alter `FreeBalance` and `ReservedBalance` in storage. it will40       * also alter the total issuance of the system (`TotalIssuance`) appropriately.41       * If the new free or reserved balance is below the existential deposit,42       * it will reset the account nonce (`frame_system::AccountNonce`).43       * 44       * The dispatch origin for this call is `root`.45       **/46      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>]>;47      /**48       * Transfer some liquid free balance to another account.49       * 50       * `transfer` will set the `FreeBalance` of the sender and receiver.51       * If the sender's account is below the existential deposit as a result52       * of the transfer, the account will be reaped.53       * 54       * The dispatch origin for this call must be `Signed` by the transactor.55       * 56       * # <weight>57       * - Dependent on arguments but not critical, given proper implementations for input config58       * types. See related functions below.59       * - It contains a limited number of reads and writes internally and no complex60       * computation.61       * 62       * Related functions:63       * 64       * - `ensure_can_withdraw` is always called internally but has a bounded complexity.65       * - Transferring balances to accounts that did not exist before will cause66       * `T::OnNewAccount::on_new_account` to be called.67       * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.68       * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check69       * that the transfer will not kill the origin account.70       * ---------------------------------71       * - Origin account is already in memory, so no DB operations for them.72       * # </weight>73       **/74      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>]>;75      /**76       * Transfer the entire transferable balance from the caller account.77       * 78       * NOTE: This function only attempts to transfer _transferable_ balances. This means that79       * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be80       * transferred by this function. To ensure that this function results in a killed account,81       * you might need to prepare the account by removing any reference counters, storage82       * deposits, etc...83       * 84       * The dispatch origin of this call must be Signed.85       * 86       * - `dest`: The recipient of the transfer.87       * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all88       * of the funds the account has, causing the sender account to be killed (false), or89       * transfer everything except at least the existential deposit, which will guarantee to90       * keep the sender account alive (true). # <weight>91       * - O(1). Just like transfer, but reading the user's transferable balance first.92       * #</weight>93       **/94      transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;95      /**96       * Same as the [`transfer`] call, but with a check that the transfer will not kill the97       * origin account.98       * 99       * 99% of the time you want [`transfer`] instead.100       * 101       * [`transfer`]: struct.Pallet.html#method.transfer102       **/103      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>]>;104      /**105       * Generic tx106       **/107      [key: string]: SubmittableExtrinsicFunction<ApiType>;108    };109    charging: {110      /**111       * Generic tx112       **/113      [key: string]: SubmittableExtrinsicFunction<ApiType>;114    };115    configuration: {116      setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;117      setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;118      /**119       * Generic tx120       **/121      [key: string]: SubmittableExtrinsicFunction<ApiType>;122    };123    cumulusXcm: {124      /**125       * Generic tx126       **/127      [key: string]: SubmittableExtrinsicFunction<ApiType>;128    };129    dmpQueue: {130      /**131       * Service a single overweight message.132       * 133       * - `origin`: Must pass `ExecuteOverweightOrigin`.134       * - `index`: The index of the overweight message to service.135       * - `weight_limit`: The amount of weight that message execution may take.136       * 137       * Errors:138       * - `Unknown`: Message of `index` is unknown.139       * - `OverLimit`: Message execution may use greater than `weight_limit`.140       * 141       * Events:142       * - `OverweightServiced`: On success.143       **/144      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;145      /**146       * Generic tx147       **/148      [key: string]: SubmittableExtrinsicFunction<ApiType>;149    };150    ethereum: {151      /**152       * Transact an Ethereum transaction.153       **/154      transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;155      /**156       * Generic tx157       **/158      [key: string]: SubmittableExtrinsicFunction<ApiType>;159    };160    evm: {161      /**162       * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.163       **/164      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>]>>]>;165      /**166       * Issue an EVM create operation. This is similar to a contract creation transaction in167       * Ethereum.168       **/169      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>]>>]>;170      /**171       * Issue an EVM create2 operation.172       **/173      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>]>>]>;174      /**175       * Withdraw balance from EVM into currency/balances pallet.176       **/177      withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;178      /**179       * Generic tx180       **/181      [key: string]: SubmittableExtrinsicFunction<ApiType>;182    };183    evmMigration: {184      /**185       * Start contract migration, inserts contract stub at target address,186       * and marks account as pending, allowing to insert storage187       **/188      begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;189      /**190       * Finish contract migration, allows it to be called.191       * It is not possible to alter contract storage via [`Self::set_data`]192       * after this call.193       **/194      finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;195      /**196       * Insert items into contract storage, this method can be called197       * multiple times198       **/199      setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;200      /**201       * Generic tx202       **/203      [key: string]: SubmittableExtrinsicFunction<ApiType>;204    };205    inflation: {206      /**207       * This method sets the inflation start date. Can be only called once.208       * Inflation start block can be backdated and will catch up. The method will create Treasury209       * account if it does not exist and perform the first inflation deposit.210       * 211       * # Permissions212       * 213       * * Root214       * 215       * # Arguments216       * 217       * * inflation_start_relay_block: The relay chain block at which inflation should start218       **/219      startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;220      /**221       * Generic tx222       **/223      [key: string]: SubmittableExtrinsicFunction<ApiType>;224    };225    parachainSystem: {226      authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;227      enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;228      /**229       * Set the current validation data.230       * 231       * This should be invoked exactly once per block. It will panic at the finalization232       * phase if the call was not invoked.233       * 234       * The dispatch origin for this call must be `Inherent`235       * 236       * As a side effect, this function upgrades the current validation function237       * if the appropriate time has come.238       **/239      setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;240      sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;241      /**242       * Generic tx243       **/244      [key: string]: SubmittableExtrinsicFunction<ApiType>;245    };246    polkadotXcm: {247      /**248       * Execute an XCM message from a local, signed, origin.249       * 250       * An event is deposited indicating whether `msg` could be executed completely or only251       * partially.252       * 253       * No more than `max_weight` will be used in its attempted execution. If this is less than the254       * maximum amount of weight that the message could take to be executed, then no execution255       * attempt will be made.256       * 257       * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully258       * to completion; only that *some* of it was executed.259       **/260      execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;261      /**262       * Set a safe XCM version (the version that XCM should be encoded with if the most recent263       * version a destination can accept is unknown).264       * 265       * - `origin`: Must be Root.266       * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.267       **/268      forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;269      /**270       * Ask a location to notify us regarding their XCM version and any changes to it.271       * 272       * - `origin`: Must be Root.273       * - `location`: The location to which we should subscribe for XCM version notifications.274       **/275      forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;276      /**277       * Require that a particular destination should no longer notify us regarding any XCM278       * version changes.279       * 280       * - `origin`: Must be Root.281       * - `location`: The location to which we are currently subscribed for XCM version282       * notifications which we no longer desire.283       **/284      forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;285      /**286       * Extoll that a particular destination can be communicated with through a particular287       * version of XCM.288       * 289       * - `origin`: Must be Root.290       * - `location`: The destination that is being described.291       * - `xcm_version`: The latest version of XCM that `location` supports.292       **/293      forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;294      /**295       * Transfer some assets from the local chain to the sovereign account of a destination296       * chain and forward a notification XCM.297       * 298       * Fee payment on the destination side is made from the asset in the `assets` vector of299       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight300       * is needed than `weight_limit`, then the operation will fail and the assets send may be301       * at risk.302       * 303       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.304       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send305       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.306       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be307       * an `AccountId32` value.308       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the309       * `dest` side.310       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay311       * fees.312       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.313       **/314      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]>;315      /**316       * Teleport some assets from the local chain to some destination chain.317       * 318       * Fee payment on the destination side is made from the asset in the `assets` vector of319       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight320       * is needed than `weight_limit`, then the operation will fail and the assets send may be321       * at risk.322       * 323       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.324       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send325       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.326       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be327       * an `AccountId32` value.328       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the329       * `dest` side. May not be empty.330       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay331       * fees.332       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.333       **/334      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]>;335      /**336       * Transfer some assets from the local chain to the sovereign account of a destination337       * chain and forward a notification XCM.338       * 339       * Fee payment on the destination side is made from the asset in the `assets` vector of340       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,341       * with all fees taken as needed from the asset.342       * 343       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.344       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send345       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.346       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be347       * an `AccountId32` value.348       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the349       * `dest` side.350       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay351       * fees.352       **/353      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]>;354      send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;355      /**356       * Teleport some assets from the local chain to some destination chain.357       * 358       * Fee payment on the destination side is made from the asset in the `assets` vector of359       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,360       * with all fees taken as needed from the asset.361       * 362       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.363       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send364       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.365       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be366       * an `AccountId32` value.367       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the368       * `dest` side. May not be empty.369       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay370       * fees.371       **/372      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]>;373      /**374       * Generic tx375       **/376      [key: string]: SubmittableExtrinsicFunction<ApiType>;377    };378    promotion: {379      payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;380      setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;381      sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;382      sponsorConract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;383      stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;384      startAppPromotion: AugmentedSubmittable<(promotionStartRelayBlock: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;385      stopAppPromotion: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;386      stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;387      stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;388      unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;389      /**390       * Generic tx391       **/392      [key: string]: SubmittableExtrinsicFunction<ApiType>;393    };394    rmrkCore: {395      /**396       * Accept an NFT sent from another account to self or an owned NFT.397       * 398       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.399       * 400       * # Permissions:401       * - Token-owner-to-be402       * 403       * # Arguments:404       * - `origin`: sender of the transaction405       * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.406       * - `rmrk_nft_id`: ID of the NFT to be accepted.407       * - `new_owner`: Either the sender's account ID or a sender-owned NFT,408       * whichever the accepted NFT was sent to.409       **/410      acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;411      /**412       * Accept the addition of a newly created pending resource to an existing NFT.413       * 414       * This transaction is needed when a resource is created and assigned to an NFT415       * by a non-owner, i.e. the collection issuer, with one of the416       * [`add_...` transactions](Pallet::add_basic_resource).417       * 418       * # Permissions:419       * - Token owner420       * 421       * # Arguments:422       * - `origin`: sender of the transaction423       * - `rmrk_collection_id`: RMRK collection ID of the NFT.424       * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.425       * - `resource_id`: ID of the newly created pending resource.426       * accept the addition of a new resource to an existing NFT427       **/428      acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;429      /**430       * Accept the removal of a removal-pending resource from an NFT.431       * 432       * This transaction is needed when a non-owner, i.e. the collection issuer,433       * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.434       * 435       * # Permissions:436       * - Token owner437       * 438       * # Arguments:439       * - `origin`: sender of the transaction440       * - `rmrk_collection_id`: RMRK collection ID of the NFT.441       * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.442       * - `resource_id`: ID of the removal-pending resource.443       **/444      acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;445      /**446       * Create and set/propose a basic resource for an NFT.447       * 448       * A basic resource is the simplest, lacking a Base and anything that comes with it.449       * See RMRK docs for more information and examples.450       * 451       * # Permissions:452       * - Collection issuer - if not the token owner, adding the resource will warrant453       * the owner's [acceptance](Pallet::accept_resource).454       * 455       * # Arguments:456       * - `origin`: sender of the transaction457       * - `rmrk_collection_id`: RMRK collection ID of the NFT.458       * - `nft_id`: ID of the NFT to assign a resource to.459       * - `resource`: Data of the resource to be created.460       **/461      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]>;462      /**463       * Create and set/propose a composable resource for an NFT.464       * 465       * A composable resource links to a Base and has a subset of its Parts it is composed of.466       * See RMRK docs for more information and examples.467       * 468       * # Permissions:469       * - Collection issuer - if not the token owner, adding the resource will warrant470       * the owner's [acceptance](Pallet::accept_resource).471       * 472       * # Arguments:473       * - `origin`: sender of the transaction474       * - `rmrk_collection_id`: RMRK collection ID of the NFT.475       * - `nft_id`: ID of the NFT to assign a resource to.476       * - `resource`: Data of the resource to be created.477       **/478      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]>;479      /**480       * Create and set/propose a slot resource for an NFT.481       * 482       * A slot resource links to a Base and a slot ID in it which it can fit into.483       * See RMRK docs for more information and examples.484       * 485       * # Permissions:486       * - Collection issuer - if not the token owner, adding the resource will warrant487       * the owner's [acceptance](Pallet::accept_resource).488       * 489       * # Arguments:490       * - `origin`: sender of the transaction491       * - `rmrk_collection_id`: RMRK collection ID of the NFT.492       * - `nft_id`: ID of the NFT to assign a resource to.493       * - `resource`: Data of the resource to be created.494       **/495      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]>;496      /**497       * Burn an NFT, destroying it and its nested tokens up to the specified limit.498       * If the burning budget is exceeded, the transaction is reverted.499       * 500       * This is the way to burn a nested token as well.501       * 502       * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).503       * 504       * # Permissions:505       * * Token owner506       * 507       * # Arguments:508       * - `origin`: sender of the transaction509       * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.510       * - `nft_id`: ID of the NFT to be destroyed.511       * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction512       * is reverted if there are more tokens to burn in the nesting tree than this number.513       * This is primarily a mechanism of transaction weight control.514       **/515      burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;516      /**517       * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).518       * 519       * # Permissions:520       * * Collection issuer521       * 522       * # Arguments:523       * - `origin`: sender of the transaction524       * - `collection_id`: RMRK collection ID to change the issuer of.525       * - `new_issuer`: Collection's new issuer.526       **/527      changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;528      /**529       * Create a new collection of NFTs.530       * 531       * # Permissions:532       * * Anyone - will be assigned as the issuer of the collection.533       * 534       * # Arguments:535       * - `origin`: sender of the transaction536       * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.537       * - `max`: Optional maximum number of tokens.538       * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.539       * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.540       **/541      createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;542      /**543       * Destroy a collection.544       * 545       * Only empty collections can be destroyed. If it has any tokens, they must be burned first.546       * 547       * # Permissions:548       * * Collection issuer549       * 550       * # Arguments:551       * - `origin`: sender of the transaction552       * - `collection_id`: RMRK ID of the collection to destroy.553       **/554      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;555      /**556       * "Lock" the collection and prevent new token creation. Cannot be undone.557       * 558       * # Permissions:559       * * Collection issuer560       * 561       * # Arguments:562       * - `origin`: sender of the transaction563       * - `collection_id`: RMRK ID of the collection to lock.564       **/565      lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;566      /**567       * Mint an NFT in a specified collection.568       * 569       * # Permissions:570       * * Collection issuer571       * 572       * # Arguments:573       * - `origin`: sender of the transaction574       * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).575       * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.576       * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.577       * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.578       * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.579       * - `transferable`: Can this NFT be transferred? Cannot be changed.580       * - `resources`: Resource data to be added to the NFT immediately after minting.581       **/582      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>>]>;583      /**584       * Reject an NFT sent from another account to self or owned NFT.585       * The NFT in question will not be sent back and burnt instead.586       * 587       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.588       * 589       * # Permissions:590       * - Token-owner-to-be-not591       * 592       * # Arguments:593       * - `origin`: sender of the transaction594       * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.595       * - `rmrk_nft_id`: ID of the NFT to be rejected.596       **/597      rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;598      /**599       * Remove and erase a resource from an NFT.600       * 601       * If the sender does not own the NFT, then it will be pending confirmation,602       * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.603       * 604       * # Permissions605       * - Collection issuer606       * 607       * # Arguments608       * - `origin`: sender of the transaction609       * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.610       * - `nft_id`: ID of the NFT with a resource to be removed.611       * - `resource_id`: ID of the resource to be removed.612       **/613      removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;614      /**615       * Transfer an NFT from an account/NFT A to another account/NFT B.616       * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].617       * 618       * If the target owner is an NFT owned by another account, then the NFT will enter619       * the pending state and will have to be accepted by the other account.620       * 621       * # Permissions:622       * - Token owner623       * 624       * # Arguments:625       * - `origin`: sender of the transaction626       * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.627       * - `rmrk_nft_id`: ID of the NFT to be transferred.628       * - `new_owner`: New owner of the nft which can be either an account or a NFT.629       **/630      send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;631      /**632       * Set a different order of resource priorities for an NFT. Priorities can be used,633       * for example, for order of rendering.634       * 635       * Note that the priorities are not updated automatically, and are an empty vector636       * by default. There is no pre-set definition for the order to be particular,637       * it can be interpreted arbitrarily use-case by use-case.638       * 639       * # Permissions:640       * - Token owner641       * 642       * # Arguments:643       * - `origin`: sender of the transaction644       * - `rmrk_collection_id`: RMRK collection ID of the NFT.645       * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.646       * - `priorities`: Ordered vector of resource IDs.647       **/648      setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;649      /**650       * Add or edit a custom user property, a key-value pair, describing the metadata651       * of a token or a collection, on either one of these.652       * 653       * Note that in this proxy implementation many details regarding RMRK are stored654       * as scoped properties prefixed with "rmrk:", normally inaccessible655       * to external transactions and RPCs.656       * 657       * # Permissions:658       * - Collection issuer - in case of collection property659       * - Token owner - in case of NFT property660       * 661       * # Arguments:662       * - `origin`: sender of the transaction663       * - `rmrk_collection_id`: RMRK collection ID.664       * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.665       * - `key`: Key of the custom property to be referenced by.666       * - `value`: Value of the custom property to be stored.667       **/668      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]>;669      /**670       * Generic tx671       **/672      [key: string]: SubmittableExtrinsicFunction<ApiType>;673    };674    rmrkEquip: {675      /**676       * Create a new Base.677       * 678       * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)679       * 680       * # Permissions681       * - Anyone - will be assigned as the issuer of the Base.682       * 683       * # Arguments:684       * - `origin`: Caller, will be assigned as the issuer of the Base685       * - `base_type`: Arbitrary media type, e.g. "svg".686       * - `symbol`: Arbitrary client-chosen symbol.687       * - `parts`: Array of Fixed and Slot Parts composing the Base,688       * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).689       **/690      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>]>;691      /**692       * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.693       * 694       * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).695       * 696       * # Permissions:697       * - Base issuer698       * 699       * # Arguments:700       * - `origin`: sender of the transaction701       * - `base_id`: Base containing the Slot Part to be updated.702       * - `slot_id`: Slot Part whose Equippable List is being updated .703       * - `equippables`: List of equippables that will override the current Equippables list.704       **/705      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]>;706      /**707       * Add a Theme to a Base.708       * A Theme named "default" is required prior to adding other Themes.709       * 710       * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).711       * 712       * # Permissions:713       * - Base issuer714       * 715       * # Arguments:716       * - `origin`: sender of the transaction717       * - `base_id`: Base ID containing the Theme to be updated.718       * - `theme`: Theme to add to the Base.  A Theme has a name and properties, which are an719       * array of [key, value, inherit].720       * - `key`: Arbitrary BoundedString, defined by client.721       * - `value`: Arbitrary BoundedString, defined by client.722       * - `inherit`: Optional bool.723       **/724      themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;725      /**726       * Generic tx727       **/728      [key: string]: SubmittableExtrinsicFunction<ApiType>;729    };730    scheduler: {731      /**732       * Cancel a named scheduled task.733       **/734      cancelNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed]>;735      /**736       * Schedule a named task.737       **/738      scheduleNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, FrameSupportScheduleMaybeHashed]>;739      /**740       * Schedule a named task after a delay.741       * 742       * # <weight>743       * Same as [`schedule_named`](Self::schedule_named).744       * # </weight>745       **/746      scheduleNamedAfter: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, FrameSupportScheduleMaybeHashed]>;747      /**748       * Generic tx749       **/750      [key: string]: SubmittableExtrinsicFunction<ApiType>;751    };752    structure: {753      /**754       * Generic tx755       **/756      [key: string]: SubmittableExtrinsicFunction<ApiType>;757    };758    sudo: {759      /**760       * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo761       * key.762       * 763       * The dispatch origin for this call must be _Signed_.764       * 765       * # <weight>766       * - O(1).767       * - Limited storage reads.768       * - One DB change.769       * # </weight>770       **/771      setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;772      /**773       * Authenticates the sudo key and dispatches a function call with `Root` origin.774       * 775       * The dispatch origin for this call must be _Signed_.776       * 777       * # <weight>778       * - O(1).779       * - Limited storage reads.780       * - One DB write (event).781       * - Weight of derivative `call` execution + 10,000.782       * # </weight>783       **/784      sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;785      /**786       * Authenticates the sudo key and dispatches a function call with `Signed` origin from787       * a given account.788       * 789       * The dispatch origin for this call must be _Signed_.790       * 791       * # <weight>792       * - O(1).793       * - Limited storage reads.794       * - One DB write (event).795       * - Weight of derivative `call` execution + 10,000.796       * # </weight>797       **/798      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]>;799      /**800       * Authenticates the sudo key and dispatches a function call with `Root` origin.801       * This function does not check the weight of the call, and instead allows the802       * Sudo user to specify the weight of the call.803       * 804       * The dispatch origin for this call must be _Signed_.805       * 806       * # <weight>807       * - O(1).808       * - The weight of this call is defined by the caller.809       * # </weight>810       **/811      sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, u64]>;812      /**813       * Generic tx814       **/815      [key: string]: SubmittableExtrinsicFunction<ApiType>;816    };817    system: {818      /**819       * A dispatch that will fill the block weight up to the given ratio.820       **/821      fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;822      /**823       * Kill all storage items with a key that starts with the given prefix.824       * 825       * **NOTE:** We rely on the Root origin to provide us the number of subkeys under826       * the prefix we are removing to accurately calculate the weight of this function.827       **/828      killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;829      /**830       * Kill some items from storage.831       **/832      killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;833      /**834       * Make some on-chain remark.835       * 836       * # <weight>837       * - `O(1)`838       * # </weight>839       **/840      remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;841      /**842       * Make some on-chain remark and emit event.843       **/844      remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;845      /**846       * Set the new runtime code.847       * 848       * # <weight>849       * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`850       * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is851       * expensive).852       * - 1 storage write (codec `O(C)`).853       * - 1 digest item.854       * - 1 event.855       * The weight of this function is dependent on the runtime, but generally this is very856       * expensive. We will treat this as a full block.857       * # </weight>858       **/859      setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;860      /**861       * Set the new runtime code without doing any checks of the given `code`.862       * 863       * # <weight>864       * - `O(C)` where `C` length of `code`865       * - 1 storage write (codec `O(C)`).866       * - 1 digest item.867       * - 1 event.868       * The weight of this function is dependent on the runtime. We will treat this as a full869       * block. # </weight>870       **/871      setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;872      /**873       * Set the number of pages in the WebAssembly environment's heap.874       **/875      setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;876      /**877       * Set some items of storage.878       **/879      setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;880      /**881       * Generic tx882       **/883      [key: string]: SubmittableExtrinsicFunction<ApiType>;884    };885    timestamp: {886      /**887       * Set the current time.888       * 889       * This call should be invoked exactly once per block. It will panic at the finalization890       * phase, if this call hasn't been invoked by that time.891       * 892       * The timestamp should be greater than the previous one by the amount specified by893       * `MinimumPeriod`.894       * 895       * The dispatch origin for this call must be `Inherent`.896       * 897       * # <weight>898       * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)899       * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in900       * `on_finalize`)901       * - 1 event handler `on_timestamp_set`. Must be `O(1)`.902       * # </weight>903       **/904      set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;905      /**906       * Generic tx907       **/908      [key: string]: SubmittableExtrinsicFunction<ApiType>;909    };910    treasury: {911      /**912       * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary913       * and the original deposit will be returned.914       * 915       * May only be called from `T::ApproveOrigin`.916       * 917       * # <weight>918       * - Complexity: O(1).919       * - DbReads: `Proposals`, `Approvals`920       * - DbWrite: `Approvals`921       * # </weight>922       **/923      approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;924      /**925       * Put forward a suggestion for spending. A deposit proportional to the value926       * is reserved and slashed if the proposal is rejected. It is returned once the927       * proposal is awarded.928       * 929       * # <weight>930       * - Complexity: O(1)931       * - DbReads: `ProposalCount`, `origin account`932       * - DbWrites: `ProposalCount`, `Proposals`, `origin account`933       * # </weight>934       **/935      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]>;936      /**937       * Reject a proposed spend. The original deposit will be slashed.938       * 939       * May only be called from `T::RejectOrigin`.940       * 941       * # <weight>942       * - Complexity: O(1)943       * - DbReads: `Proposals`, `rejected proposer account`944       * - DbWrites: `Proposals`, `rejected proposer account`945       * # </weight>946       **/947      rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;948      /**949       * Force a previously approved proposal to be removed from the approval queue.950       * The original deposit will no longer be returned.951       * 952       * May only be called from `T::RejectOrigin`.953       * - `proposal_id`: The index of a proposal954       * 955       * # <weight>956       * - Complexity: O(A) where `A` is the number of approvals957       * - Db reads and writes: `Approvals`958       * # </weight>959       * 960       * Errors:961       * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,962       * i.e., the proposal has not been approved. This could also mean the proposal does not963       * exist altogether, thus there is no way it would have been approved in the first place.964       **/965      removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;966      /**967       * Propose and approve a spend of treasury funds.968       * 969       * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.970       * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.971       * - `beneficiary`: The destination account for the transfer.972       * 973       * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the974       * beneficiary.975       **/976      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]>;977      /**978       * Generic tx979       **/980      [key: string]: SubmittableExtrinsicFunction<ApiType>;981    };982    unique: {983      /**984       * Add an admin to a collection.985       * 986       * NFT Collection can be controlled by multiple admin addresses987       * (some which can also be servers, for example). Admins can issue988       * and burn NFTs, as well as add and remove other admins,989       * but cannot change NFT or Collection ownership.990       * 991       * # Permissions992       * 993       * * Collection owner994       * * Collection admin995       * 996       * # Arguments997       * 998       * * `collection_id`: ID of the Collection to add an admin for.999       * * `new_admin`: Address of new admin to add.1000       **/1001      addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1002      /**1003       * Add an address to allow list.1004       * 1005       * # Permissions1006       * 1007       * * Collection owner1008       * * Collection admin1009       * 1010       * # Arguments1011       * 1012       * * `collection_id`: ID of the modified collection.1013       * * `address`: ID of the address to be added to the allowlist.1014       **/1015      addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1016      /**1017       * Allow a non-permissioned address to transfer or burn an item.1018       * 1019       * # Permissions1020       * 1021       * * Collection owner1022       * * Collection admin1023       * * Current item owner1024       * 1025       * # Arguments1026       * 1027       * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1028       * * `collection_id`: ID of the collection the item belongs to.1029       * * `item_id`: ID of the item transactions on which are now approved.1030       * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1031       * Set to 0 to revoke the approval.1032       **/1033      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]>;1034      /**1035       * Destroy a token on behalf of the owner as a non-owner account.1036       * 1037       * See also: [`approve`][`Pallet::approve`].1038       * 1039       * After this method executes, one approval is removed from the total so that1040       * the approved address will not be able to transfer this item again from this owner.1041       * 1042       * # Permissions1043       * 1044       * * Collection owner1045       * * Collection admin1046       * * Current token owner1047       * * Address approved by current item owner1048       * 1049       * # Arguments1050       * 1051       * * `from`: The owner of the burning item.1052       * * `collection_id`: ID of the collection to which the item belongs.1053       * * `item_id`: ID of item to burn.1054       * * `value`: Number of pieces to burn.1055       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1056       * * Fungible Mode: The desired number of pieces to burn.1057       * * Re-Fungible Mode: The desired number of pieces to burn.1058       **/1059      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]>;1060      /**1061       * Destroy an item.1062       * 1063       * # Permissions1064       * 1065       * * Collection owner1066       * * Collection admin1067       * * Current item owner1068       * 1069       * # Arguments1070       * 1071       * * `collection_id`: ID of the collection to which the item belongs.1072       * * `item_id`: ID of item to burn.1073       * * `value`: Number of pieces of the item to destroy.1074       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1075       * * Fungible Mode: The desired number of pieces to burn.1076       * * Re-Fungible Mode: The desired number of pieces to burn.1077       **/1078      burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1079      /**1080       * Change the owner of the collection.1081       * 1082       * # Permissions1083       * 1084       * * Collection owner1085       * 1086       * # Arguments1087       * 1088       * * `collection_id`: ID of the modified collection.1089       * * `new_owner`: ID of the account that will become the owner.1090       **/1091      changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1092      /**1093       * Confirm own sponsorship of a collection, becoming the sponsor.1094       * 1095       * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1096       * Sponsor can pay the fees of a transaction instead of the sender,1097       * but only within specified limits.1098       * 1099       * # Permissions1100       * 1101       * * Sponsor-to-be1102       * 1103       * # Arguments1104       * 1105       * * `collection_id`: ID of the collection with the pending sponsor.1106       **/1107      confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1108      /**1109       * Create a collection of tokens.1110       * 1111       * Each Token may have multiple properties encoded as an array of bytes1112       * of certain length. The initial owner of the collection is set1113       * to the address that signed the transaction and can be changed later.1114       * 1115       * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1116       * 1117       * # Permissions1118       * 1119       * * Anyone - becomes the owner of the new collection.1120       * 1121       * # Arguments1122       * 1123       * * `collection_name`: Wide-character string with collection name1124       * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1125       * * `collection_description`: Wide-character string with collection description1126       * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1127       * * `token_prefix`: Byte string containing the token prefix to mark a collection1128       * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1129       * * `mode`: Type of items stored in the collection and type dependent data.1130       **/1131      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]>;1132      /**1133       * Create a collection with explicit parameters.1134       * 1135       * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1136       * 1137       * # Permissions1138       * 1139       * * Anyone - becomes the owner of the new collection.1140       * 1141       * # Arguments1142       * 1143       * * `data`: Explicit data of a collection used for its creation.1144       **/1145      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]>;1146      /**1147       * Mint an item within a collection.1148       * 1149       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1150       * 1151       * # Permissions1152       * 1153       * * Collection owner1154       * * Collection admin1155       * * Anyone if1156       * * Allow List is enabled, and1157       * * Address is added to allow list, and1158       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1159       * 1160       * # Arguments1161       * 1162       * * `collection_id`: ID of the collection to which an item would belong.1163       * * `owner`: Address of the initial owner of the item.1164       * * `data`: Token data describing the item to store on chain.1165       **/1166      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]>;1167      /**1168       * Create multiple items within a collection.1169       * 1170       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1171       * 1172       * # Permissions1173       * 1174       * * Collection owner1175       * * Collection admin1176       * * Anyone if1177       * * Allow List is enabled, and1178       * * Address is added to the allow list, and1179       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1180       * 1181       * # Arguments1182       * 1183       * * `collection_id`: ID of the collection to which the tokens would belong.1184       * * `owner`: Address of the initial owner of the tokens.1185       * * `items_data`: Vector of data describing each item to be created.1186       **/1187      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>]>;1188      /**1189       * Create multiple items within a collection with explicitly specified initial parameters.1190       * 1191       * # Permissions1192       * 1193       * * Collection owner1194       * * Collection admin1195       * * Anyone if1196       * * Allow List is enabled, and1197       * * Address is added to allow list, and1198       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1199       * 1200       * # Arguments1201       * 1202       * * `collection_id`: ID of the collection to which the tokens would belong.1203       * * `data`: Explicit item creation data.1204       **/1205      createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1206      /**1207       * Delete specified collection properties.1208       * 1209       * # Permissions1210       * 1211       * * Collection Owner1212       * * Collection Admin1213       * 1214       * # Arguments1215       * 1216       * * `collection_id`: ID of the modified collection.1217       * * `property_keys`: Vector of keys of the properties to be deleted.1218       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1219       **/1220      deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1221      /**1222       * Delete specified token properties. Currently properties only work with NFTs.1223       * 1224       * # Permissions1225       * 1226       * * Depends on collection's token property permissions and specified property mutability:1227       * * Collection owner1228       * * Collection admin1229       * * Token owner1230       * 1231       * # Arguments1232       * 1233       * * `collection_id`: ID of the collection to which the token belongs.1234       * * `token_id`: ID of the modified token.1235       * * `property_keys`: Vector of keys of the properties to be deleted.1236       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1237       **/1238      deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1239      /**1240       * Destroy a collection if no tokens exist within.1241       * 1242       * # Permissions1243       * 1244       * * Collection owner1245       * 1246       * # Arguments1247       * 1248       * * `collection_id`: Collection to destroy.1249       **/1250      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1251      /**1252       * Remove admin of a collection.1253       * 1254       * An admin address can remove itself. List of admins may become empty,1255       * in which case only Collection Owner will be able to add an Admin.1256       * 1257       * # Permissions1258       * 1259       * * Collection owner1260       * * Collection admin1261       * 1262       * # Arguments1263       * 1264       * * `collection_id`: ID of the collection to remove the admin for.1265       * * `account_id`: Address of the admin to remove.1266       **/1267      removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1268      /**1269       * Remove a collection's a sponsor, making everyone pay for their own transactions.1270       * 1271       * # Permissions1272       * 1273       * * Collection owner1274       * 1275       * # Arguments1276       * 1277       * * `collection_id`: ID of the collection with the sponsor to remove.1278       **/1279      removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1280      /**1281       * Remove an address from allow list.1282       * 1283       * # Permissions1284       * 1285       * * Collection owner1286       * * Collection admin1287       * 1288       * # Arguments1289       * 1290       * * `collection_id`: ID of the modified collection.1291       * * `address`: ID of the address to be removed from the allowlist.1292       **/1293      removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1294      /**1295       * Re-partition a refungible token, while owning all of its parts/pieces.1296       * 1297       * # Permissions1298       * 1299       * * Token owner (must own every part)1300       * 1301       * # Arguments1302       * 1303       * * `collection_id`: ID of the collection the RFT belongs to.1304       * * `token_id`: ID of the RFT.1305       * * `amount`: New number of parts/pieces into which the token shall be partitioned.1306       **/1307      repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1308      /**1309       * Set specific limits of a collection. Empty, or None fields mean chain default.1310       * 1311       * # Permissions1312       * 1313       * * Collection owner1314       * * Collection admin1315       * 1316       * # Arguments1317       * 1318       * * `collection_id`: ID of the modified collection.1319       * * `new_limit`: New limits of the collection. Fields that are not set (None)1320       * will not overwrite the old ones.1321       **/1322      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]>;1323      /**1324       * Set specific permissions of a collection. Empty, or None fields mean chain default.1325       * 1326       * # Permissions1327       * 1328       * * Collection owner1329       * * Collection admin1330       * 1331       * # Arguments1332       * 1333       * * `collection_id`: ID of the modified collection.1334       * * `new_permission`: New permissions of the collection. Fields that are not set (None)1335       * will not overwrite the old ones.1336       **/1337      setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1338      /**1339       * Add or change collection properties.1340       * 1341       * # Permissions1342       * 1343       * * Collection owner1344       * * Collection admin1345       * 1346       * # Arguments1347       * 1348       * * `collection_id`: ID of the modified collection.1349       * * `properties`: Vector of key-value pairs stored as the collection's metadata.1350       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1351       **/1352      setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1353      /**1354       * Set (invite) a new collection sponsor.1355       * 1356       * If successful, confirmation from the sponsor-to-be will be pending.1357       * 1358       * # Permissions1359       * 1360       * * Collection owner1361       * * Collection admin1362       * 1363       * # Arguments1364       * 1365       * * `collection_id`: ID of the modified collection.1366       * * `new_sponsor`: ID of the account of the sponsor-to-be.1367       **/1368      setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1369      /**1370       * Add or change token properties according to collection's permissions.1371       * Currently properties only work with NFTs.1372       * 1373       * # Permissions1374       * 1375       * * Depends on collection's token property permissions and specified property mutability:1376       * * Collection owner1377       * * Collection admin1378       * * Token owner1379       * 1380       * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1381       * 1382       * # Arguments1383       * 1384       * * `collection_id: ID of the collection to which the token belongs.1385       * * `token_id`: ID of the modified token.1386       * * `properties`: Vector of key-value pairs stored as the token's metadata.1387       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1388       **/1389      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>]>;1390      /**1391       * Add or change token property permissions of a collection.1392       * 1393       * Without a permission for a particular key, a property with that key1394       * cannot be created in a token.1395       * 1396       * # Permissions1397       * 1398       * * Collection owner1399       * * Collection admin1400       * 1401       * # Arguments1402       * 1403       * * `collection_id`: ID of the modified collection.1404       * * `property_permissions`: Vector of permissions for property keys.1405       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1406       **/1407      setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1408      /**1409       * Completely allow or disallow transfers for a particular collection.1410       * 1411       * # Permissions1412       * 1413       * * Collection owner1414       * 1415       * # Arguments1416       * 1417       * * `collection_id`: ID of the collection.1418       * * `value`: New value of the flag, are transfers allowed?1419       **/1420      setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1421      /**1422       * Change ownership of the token.1423       * 1424       * # Permissions1425       * 1426       * * Collection owner1427       * * Collection admin1428       * * Current token owner1429       * 1430       * # Arguments1431       * 1432       * * `recipient`: Address of token recipient.1433       * * `collection_id`: ID of the collection the item belongs to.1434       * * `item_id`: ID of the item.1435       * * Non-Fungible Mode: Required.1436       * * Fungible Mode: Ignored.1437       * * Re-Fungible Mode: Required.1438       * 1439       * * `value`: Amount to transfer.1440       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1441       * * Fungible Mode: The desired number of pieces to transfer.1442       * * Re-Fungible Mode: The desired number of pieces to transfer.1443       **/1444      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]>;1445      /**1446       * Change ownership of an item on behalf of the owner as a non-owner account.1447       * 1448       * See the [`approve`][`Pallet::approve`] method for additional information.1449       * 1450       * After this method executes, one approval is removed from the total so that1451       * the approved address will not be able to transfer this item again from this owner.1452       * 1453       * # Permissions1454       * 1455       * * Collection owner1456       * * Collection admin1457       * * Current item owner1458       * * Address approved by current item owner1459       * 1460       * # Arguments1461       * 1462       * * `from`: Address that currently owns the token.1463       * * `recipient`: Address of the new token-owner-to-be.1464       * * `collection_id`: ID of the collection the item.1465       * * `item_id`: ID of the item to be transferred.1466       * * `value`: Amount to transfer.1467       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1468       * * Fungible Mode: The desired number of pieces to transfer.1469       * * Re-Fungible Mode: The desired number of pieces to transfer.1470       **/1471      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]>;1472      /**1473       * Generic tx1474       **/1475      [key: string]: SubmittableExtrinsicFunction<ApiType>;1476    };1477    vesting: {1478      claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1479      claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1480      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>]>;1481      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]>;1482      /**1483       * Generic tx1484       **/1485      [key: string]: SubmittableExtrinsicFunction<ApiType>;1486    };1487    xcmpQueue: {1488      /**1489       * Resumes all XCM executions for the XCMP queue.1490       * 1491       * Note that this function doesn't change the status of the in/out bound channels.1492       * 1493       * - `origin`: Must pass `ControllerOrigin`.1494       **/1495      resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1496      /**1497       * Services a single overweight XCM.1498       * 1499       * - `origin`: Must pass `ExecuteOverweightOrigin`.1500       * - `index`: The index of the overweight XCM to service1501       * - `weight_limit`: The amount of weight that XCM execution may take.1502       * 1503       * Errors:1504       * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1505       * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1506       * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1507       * 1508       * Events:1509       * - `OverweightServiced`: On success.1510       **/1511      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1512      /**1513       * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1514       * 1515       * - `origin`: Must pass `ControllerOrigin`.1516       **/1517      suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1518      /**1519       * Overwrites the number of pages of messages which must be in the queue after which we drop any further1520       * messages from the channel.1521       * 1522       * - `origin`: Must pass `Root`.1523       * - `new`: Desired value for `QueueConfigData.drop_threshold`1524       **/1525      updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1526      /**1527       * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1528       * message sending may recommence after it has been suspended.1529       * 1530       * - `origin`: Must pass `Root`.1531       * - `new`: Desired value for `QueueConfigData.resume_threshold`1532       **/1533      updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1534      /**1535       * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1536       * suspend their sending.1537       * 1538       * - `origin`: Must pass `Root`.1539       * - `new`: Desired value for `QueueConfigData.suspend_value`1540       **/1541      updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1542      /**1543       * Overwrites the amount of remaining weight under which we stop processing messages.1544       * 1545       * - `origin`: Must pass `Root`.1546       * - `new`: Desired value for `QueueConfigData.threshold_weight`1547       **/1548      updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1549      /**1550       * Overwrites the speed to which the available weight approaches the maximum weight.1551       * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1552       * 1553       * - `origin`: Must pass `Root`.1554       * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1555       **/1556      updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1557      /**1558       * Overwrite the maximum amount of weight any individual message may consume.1559       * Messages above this weight go into the overweight queue and may only be serviced explicitly.1560       * 1561       * - `origin`: Must pass `Root`.1562       * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1563       **/1564      updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1565      /**1566       * Generic tx1567       **/1568      [key: string]: SubmittableExtrinsicFunction<ApiType>;1569    };1570  } // AugmentedSubmittables1571} // declare module