git.delta.rocks / unique-network / refs/commits / 308db1642565

1// Auto-generated via `yarn polkadot-types-from-chain`, do not edit2/* eslint-disable */34// import type lookup before we augment - in some environments5// this is required to allow for ambient/previous definitions6import '@polkadot/api-base/types/submittable';78import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types';9import type { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';10import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';11import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill } from '@polkadot/types/interfaces/runtime';12import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumLog, EthereumTransactionTransactionV2, OpalRuntimeRuntimeCommonSessionKeys, OrmlVestingVestingSchedule, PalletConfigurationAppPromotionConfiguration, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, SpRuntimeHeader, SpWeightsWeightV2Weight, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';1314export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;15export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;16export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;1718declare module '@polkadot/api-base/types/submittable' {19  interface AugmentedSubmittables<ApiType extends ApiTypes> {20    appPromotion: {21      /**22       * Recalculates interest for the specified number of stakers.23       * If all stakers are not recalculated, the next call of the extrinsic24       * will continue the recalculation, from those stakers for whom this25       * was not perform in last call.26       * 27       * # Permissions28       * 29       * * Pallet admin30       * 31       * # Arguments32       * 33       * * `stakers_number`: the number of stakers for which recalculation will be performed34       **/35      payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;36      /**37       * Sets an address as the the admin.38       * 39       * # Permissions40       * 41       * * Sudo42       * 43       * # Arguments44       * 45       * * `admin`: account of the new admin.46       **/47      setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;48      /**49       * Sets the pallet to be the sponsor for the collection.50       * 51       * # Permissions52       * 53       * * Pallet admin54       * 55       * # Arguments56       * 57       * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`58       **/59      sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;60      /**61       * Sets the pallet to be the sponsor for the contract.62       * 63       * # Permissions64       * 65       * * Pallet admin66       * 67       * # Arguments68       * 69       * * `contract_id`: the contract address that will be sponsored by `pallet_id`70       **/71      sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;72      /**73       * Stakes the amount of native tokens.74       * Sets `amount` to the locked state.75       * The maximum number of stakes for a staker is 10.76       * 77       * # Arguments78       * 79       * * `amount`: in native tokens.80       **/81      stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;82      /**83       * Removes the pallet as the sponsor for the collection.84       * Returns [`NoPermission`][`Error::NoPermission`]85       * if the pallet wasn't the sponsor.86       * 87       * # Permissions88       * 89       * * Pallet admin90       * 91       * # Arguments92       * 93       * * `collection_id`: ID of the collection that is sponsored by `pallet_id`94       **/95      stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;96      /**97       * Removes the pallet as the sponsor for the contract.98       * Returns [`NoPermission`][`Error::NoPermission`]99       * if the pallet wasn't the sponsor.100       * 101       * # Permissions102       * 103       * * Pallet admin104       * 105       * # Arguments106       * 107       * * `contract_id`: the contract address that is sponsored by `pallet_id`108       **/109      stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;110      /**111       * Unstakes all stakes.112       * Moves the sum of all stakes to the `reserved` state.113       * After the end of `PendingInterval` this sum becomes completely114       * free for further use.115       **/116      unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;117      /**118       * Generic tx119       **/120      [key: string]: SubmittableExtrinsicFunction<ApiType>;121    };122    authorship: {123      /**124       * Provide a set of uncles.125       **/126      setUncles: AugmentedSubmittable<(newUncles: Vec<SpRuntimeHeader> | (SpRuntimeHeader | { parentHash?: any; number?: any; stateRoot?: any; extrinsicsRoot?: any; digest?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<SpRuntimeHeader>]>;127      /**128       * Generic tx129       **/130      [key: string]: SubmittableExtrinsicFunction<ApiType>;131    };132    balances: {133      /**134       * Exactly as `transfer`, except the origin must be root and the source account may be135       * specified.136       * # <weight>137       * - Same as transfer, but additional read and write because the source account is not138       * assumed to be in the overlay.139       * # </weight>140       **/141      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>]>;142      /**143       * Unreserve some balance from a user by force.144       * 145       * Can only be called by ROOT.146       **/147      forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;148      /**149       * Set the balances of a given account.150       * 151       * This will alter `FreeBalance` and `ReservedBalance` in storage. it will152       * also alter the total issuance of the system (`TotalIssuance`) appropriately.153       * If the new free or reserved balance is below the existential deposit,154       * it will reset the account nonce (`frame_system::AccountNonce`).155       * 156       * The dispatch origin for this call is `root`.157       **/158      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>]>;159      /**160       * Transfer some liquid free balance to another account.161       * 162       * `transfer` will set the `FreeBalance` of the sender and receiver.163       * If the sender's account is below the existential deposit as a result164       * of the transfer, the account will be reaped.165       * 166       * The dispatch origin for this call must be `Signed` by the transactor.167       * 168       * # <weight>169       * - Dependent on arguments but not critical, given proper implementations for input config170       * types. See related functions below.171       * - It contains a limited number of reads and writes internally and no complex172       * computation.173       * 174       * Related functions:175       * 176       * - `ensure_can_withdraw` is always called internally but has a bounded complexity.177       * - Transferring balances to accounts that did not exist before will cause178       * `T::OnNewAccount::on_new_account` to be called.179       * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.180       * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check181       * that the transfer will not kill the origin account.182       * ---------------------------------183       * - Origin account is already in memory, so no DB operations for them.184       * # </weight>185       **/186      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>]>;187      /**188       * Transfer the entire transferable balance from the caller account.189       * 190       * NOTE: This function only attempts to transfer _transferable_ balances. This means that191       * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be192       * transferred by this function. To ensure that this function results in a killed account,193       * you might need to prepare the account by removing any reference counters, storage194       * deposits, etc...195       * 196       * The dispatch origin of this call must be Signed.197       * 198       * - `dest`: The recipient of the transfer.199       * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all200       * of the funds the account has, causing the sender account to be killed (false), or201       * transfer everything except at least the existential deposit, which will guarantee to202       * keep the sender account alive (true). # <weight>203       * - O(1). Just like transfer, but reading the user's transferable balance first.204       * #</weight>205       **/206      transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;207      /**208       * Same as the [`transfer`] call, but with a check that the transfer will not kill the209       * origin account.210       * 211       * 99% of the time you want [`transfer`] instead.212       * 213       * [`transfer`]: struct.Pallet.html#method.transfer214       **/215      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>]>;216      /**217       * Generic tx218       **/219      [key: string]: SubmittableExtrinsicFunction<ApiType>;220    };221    charging: {222      /**223       * Generic tx224       **/225      [key: string]: SubmittableExtrinsicFunction<ApiType>;226    };227    collatorSelection: {228      /**229       * Add a collator to the list of invulnerable (fixed) collators.230       **/231      addInvulnerable: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;232      /**233       * Force deregister `origin` as a collator candidate as a governing authority, and revoke its license.234       * Note that the collator can only leave on session change.235       * The `LicenseBond` will be unreserved and returned immediately.236       * 237       * This call is not available to `Invulnerable` collators.238       **/239      forceRevokeLicense: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;240      /**241       * Purchase a license on block collation for this account.242       * It does not make it a collator candidate, use `onboard` afterward. The account must243       * (a) already have registered session keys and (b) be able to reserve the `LicenseBond`.244       * 245       * This call is not available to `Invulnerable` collators.246       **/247      getLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;248      /**249       * Deregister `origin` as a collator candidate. Note that the collator can only leave on250       * session change. The license to `onboard` later at any other time will remain.251       * 252       * This call will fail if the total number of candidates would drop below `MinCandidates`. todo:collator maybe not253       **/254      offboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;255      /**256       * Register this account as a candidate for collators for next sessions.257       * The account must already hold a license, and cannot offboard immediately during a session.258       * 259       * This call is not available to `Invulnerable` collators.260       **/261      onboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;262      /**263       * Forfeit `origin`'s own license. The `LicenseBond` will be unreserved immediately.264       * 265       * This call is not available to `Invulnerable` collators.266       **/267      releaseLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;268      /**269       * Remove a collator from the list of invulnerable (fixed) collators.270       **/271      removeInvulnerable: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;272      /**273       * Set the ideal number of collators. If lowering this number,274       * then the number of running collators could be higher than this figure.275       * Aside from that edge case, there should be no other way to have more collators than the desired number.276       **/277      setDesiredCollators: AugmentedSubmittable<(max: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;278      /**279       * Set the length of the kick threshold.280       * Note that if the length is not a multiple of the session period, it might get inconsistent.281       **/282      setKickThreshold: AugmentedSubmittable<(kickThreshold: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;283      /**284       * Set the candidacy bond amount.285       **/286      setLicenseBond: AugmentedSubmittable<(bond: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;287      /**288       * Generic tx289       **/290      [key: string]: SubmittableExtrinsicFunction<ApiType>;291    };292    configuration: {293      setAppPromotionConfigurationOverride: AugmentedSubmittable<(configuration: PalletConfigurationAppPromotionConfiguration | { recalculationInterval?: any; pendingInterval?: any; intervalIncome?: any; maxStakersPerCalculation?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletConfigurationAppPromotionConfiguration]>;294      setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;295      setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;296      setXcmAllowedLocations: AugmentedSubmittable<(locations: Option<Vec<XcmV1MultiLocation>> | null | Uint8Array | Vec<XcmV1MultiLocation> | (XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<Vec<XcmV1MultiLocation>>]>;297      /**298       * Generic tx299       **/300      [key: string]: SubmittableExtrinsicFunction<ApiType>;301    };302    cumulusXcm: {303      /**304       * Generic tx305       **/306      [key: string]: SubmittableExtrinsicFunction<ApiType>;307    };308    dmpQueue: {309      /**310       * Service a single overweight message.311       * 312       * - `origin`: Must pass `ExecuteOverweightOrigin`.313       * - `index`: The index of the overweight message to service.314       * - `weight_limit`: The amount of weight that message execution may take.315       * 316       * Errors:317       * - `Unknown`: Message of `index` is unknown.318       * - `OverLimit`: Message execution may use greater than `weight_limit`.319       * 320       * Events:321       * - `OverweightServiced`: On success.322       **/323      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;324      /**325       * Generic tx326       **/327      [key: string]: SubmittableExtrinsicFunction<ApiType>;328    };329    ethereum: {330      /**331       * Transact an Ethereum transaction.332       **/333      transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;334      /**335       * Generic tx336       **/337      [key: string]: SubmittableExtrinsicFunction<ApiType>;338    };339    evm: {340      /**341       * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.342       **/343      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>]>>]>;344      /**345       * Issue an EVM create operation. This is similar to a contract creation transaction in346       * Ethereum.347       **/348      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>]>>]>;349      /**350       * Issue an EVM create2 operation.351       **/352      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>]>>]>;353      /**354       * Withdraw balance from EVM into currency/balances pallet.355       **/356      withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;357      /**358       * Generic tx359       **/360      [key: string]: SubmittableExtrinsicFunction<ApiType>;361    };362    evmMigration: {363      /**364       * Start contract migration, inserts contract stub at target address,365       * and marks account as pending, allowing to insert storage366       **/367      begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;368      /**369       * Finish contract migration, allows it to be called.370       * It is not possible to alter contract storage via [`Self::set_data`]371       * after this call.372       **/373      finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;374      /**375       * Create ethereum events attached to the fake transaction376       **/377      insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;378      /**379       * Create substrate events380       **/381      insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;382      /**383       * Insert items into contract storage, this method can be called384       * multiple times385       **/386      setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;387      /**388       * Generic tx389       **/390      [key: string]: SubmittableExtrinsicFunction<ApiType>;391    };392    foreignAssets: {393      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]>;394      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]>;395      /**396       * Generic tx397       **/398      [key: string]: SubmittableExtrinsicFunction<ApiType>;399    };400    inflation: {401      /**402       * This method sets the inflation start date. Can be only called once.403       * Inflation start block can be backdated and will catch up. The method will create Treasury404       * account if it does not exist and perform the first inflation deposit.405       * 406       * # Permissions407       * 408       * * Root409       * 410       * # Arguments411       * 412       * * inflation_start_relay_block: The relay chain block at which inflation should start413       **/414      startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;415      /**416       * Generic tx417       **/418      [key: string]: SubmittableExtrinsicFunction<ApiType>;419    };420    maintenance: {421      disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;422      enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;423      /**424       * Generic tx425       **/426      [key: string]: SubmittableExtrinsicFunction<ApiType>;427    };428    parachainSystem: {429      authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;430      enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;431      /**432       * Set the current validation data.433       * 434       * This should be invoked exactly once per block. It will panic at the finalization435       * phase if the call was not invoked.436       * 437       * The dispatch origin for this call must be `Inherent`438       * 439       * As a side effect, this function upgrades the current validation function440       * if the appropriate time has come.441       **/442      setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;443      sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;444      /**445       * Generic tx446       **/447      [key: string]: SubmittableExtrinsicFunction<ApiType>;448    };449    polkadotXcm: {450      /**451       * Execute an XCM message from a local, signed, origin.452       * 453       * An event is deposited indicating whether `msg` could be executed completely or only454       * partially.455       * 456       * No more than `max_weight` will be used in its attempted execution. If this is less than the457       * maximum amount of weight that the message could take to be executed, then no execution458       * attempt will be made.459       * 460       * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully461       * to completion; only that *some* of it was executed.462       **/463      execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;464      /**465       * Set a safe XCM version (the version that XCM should be encoded with if the most recent466       * version a destination can accept is unknown).467       * 468       * - `origin`: Must be Root.469       * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.470       **/471      forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;472      /**473       * Ask a location to notify us regarding their XCM version and any changes to it.474       * 475       * - `origin`: Must be Root.476       * - `location`: The location to which we should subscribe for XCM version notifications.477       **/478      forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;479      /**480       * Require that a particular destination should no longer notify us regarding any XCM481       * version changes.482       * 483       * - `origin`: Must be Root.484       * - `location`: The location to which we are currently subscribed for XCM version485       * notifications which we no longer desire.486       **/487      forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;488      /**489       * Extoll that a particular destination can be communicated with through a particular490       * version of XCM.491       * 492       * - `origin`: Must be Root.493       * - `location`: The destination that is being described.494       * - `xcm_version`: The latest version of XCM that `location` supports.495       **/496      forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;497      /**498       * Transfer some assets from the local chain to the sovereign account of a destination499       * chain and forward a notification XCM.500       * 501       * Fee payment on the destination side is made from the asset in the `assets` vector of502       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight503       * is needed than `weight_limit`, then the operation will fail and the assets send may be504       * at risk.505       * 506       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.507       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send508       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.509       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be510       * an `AccountId32` value.511       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the512       * `dest` side.513       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay514       * fees.515       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.516       **/517      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]>;518      /**519       * Teleport some assets from the local chain to some destination chain.520       * 521       * Fee payment on the destination side is made from the asset in the `assets` vector of522       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight523       * is needed than `weight_limit`, then the operation will fail and the assets send may be524       * at risk.525       * 526       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.527       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send528       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.529       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be530       * an `AccountId32` value.531       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the532       * `dest` side. May not be empty.533       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay534       * fees.535       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.536       **/537      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]>;538      /**539       * Transfer some assets from the local chain to the sovereign account of a destination540       * chain and forward a notification XCM.541       * 542       * Fee payment on the destination side is made from the asset in the `assets` vector of543       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,544       * with all fees taken as needed from the asset.545       * 546       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.547       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send548       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.549       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be550       * an `AccountId32` value.551       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the552       * `dest` side.553       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay554       * fees.555       **/556      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]>;557      send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;558      /**559       * Teleport some assets from the local chain to some destination chain.560       * 561       * Fee payment on the destination side is made from the asset in the `assets` vector of562       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,563       * with all fees taken as needed from the asset.564       * 565       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.566       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send567       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.568       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be569       * an `AccountId32` value.570       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the571       * `dest` side. May not be empty.572       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay573       * fees.574       **/575      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]>;576      /**577       * Generic tx578       **/579      [key: string]: SubmittableExtrinsicFunction<ApiType>;580    };581    rmrkCore: {582      /**583       * Accept an NFT sent from another account to self or an owned NFT.584       * 585       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.586       * 587       * # Permissions:588       * - Token-owner-to-be589       * 590       * # Arguments:591       * - `origin`: sender of the transaction592       * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.593       * - `rmrk_nft_id`: ID of the NFT to be accepted.594       * - `new_owner`: Either the sender's account ID or a sender-owned NFT,595       * whichever the accepted NFT was sent to.596       **/597      acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;598      /**599       * Accept the addition of a newly created pending resource to an existing NFT.600       * 601       * This transaction is needed when a resource is created and assigned to an NFT602       * by a non-owner, i.e. the collection issuer, with one of the603       * [`add_...` transactions](Pallet::add_basic_resource).604       * 605       * # Permissions:606       * - Token owner607       * 608       * # Arguments:609       * - `origin`: sender of the transaction610       * - `rmrk_collection_id`: RMRK collection ID of the NFT.611       * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.612       * - `resource_id`: ID of the newly created pending resource.613       * accept the addition of a new resource to an existing NFT614       **/615      acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;616      /**617       * Accept the removal of a removal-pending resource from an NFT.618       * 619       * This transaction is needed when a non-owner, i.e. the collection issuer,620       * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.621       * 622       * # Permissions:623       * - Token owner624       * 625       * # Arguments:626       * - `origin`: sender of the transaction627       * - `rmrk_collection_id`: RMRK collection ID of the NFT.628       * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.629       * - `resource_id`: ID of the removal-pending resource.630       **/631      acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;632      /**633       * Create and set/propose a basic resource for an NFT.634       * 635       * A basic resource is the simplest, lacking a Base and anything that comes with it.636       * See RMRK docs for more information and examples.637       * 638       * # Permissions:639       * - Collection issuer - if not the token owner, adding the resource will warrant640       * the owner's [acceptance](Pallet::accept_resource).641       * 642       * # Arguments:643       * - `origin`: sender of the transaction644       * - `rmrk_collection_id`: RMRK collection ID of the NFT.645       * - `nft_id`: ID of the NFT to assign a resource to.646       * - `resource`: Data of the resource to be created.647       **/648      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]>;649      /**650       * Create and set/propose a composable resource for an NFT.651       * 652       * A composable resource links to a Base and has a subset of its Parts it is composed of.653       * See RMRK docs for more information and examples.654       * 655       * # Permissions:656       * - Collection issuer - if not the token owner, adding the resource will warrant657       * the owner's [acceptance](Pallet::accept_resource).658       * 659       * # Arguments:660       * - `origin`: sender of the transaction661       * - `rmrk_collection_id`: RMRK collection ID of the NFT.662       * - `nft_id`: ID of the NFT to assign a resource to.663       * - `resource`: Data of the resource to be created.664       **/665      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]>;666      /**667       * Create and set/propose a slot resource for an NFT.668       * 669       * A slot resource links to a Base and a slot ID in it which it can fit into.670       * See RMRK docs for more information and examples.671       * 672       * # Permissions:673       * - Collection issuer - if not the token owner, adding the resource will warrant674       * the owner's [acceptance](Pallet::accept_resource).675       * 676       * # Arguments:677       * - `origin`: sender of the transaction678       * - `rmrk_collection_id`: RMRK collection ID of the NFT.679       * - `nft_id`: ID of the NFT to assign a resource to.680       * - `resource`: Data of the resource to be created.681       **/682      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]>;683      /**684       * Burn an NFT, destroying it and its nested tokens up to the specified limit.685       * If the burning budget is exceeded, the transaction is reverted.686       * 687       * This is the way to burn a nested token as well.688       * 689       * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).690       * 691       * # Permissions:692       * * Token owner693       * 694       * # Arguments:695       * - `origin`: sender of the transaction696       * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.697       * - `nft_id`: ID of the NFT to be destroyed.698       * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction699       * is reverted if there are more tokens to burn in the nesting tree than this number.700       * This is primarily a mechanism of transaction weight control.701       **/702      burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;703      /**704       * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).705       * 706       * # Permissions:707       * * Collection issuer708       * 709       * # Arguments:710       * - `origin`: sender of the transaction711       * - `collection_id`: RMRK collection ID to change the issuer of.712       * - `new_issuer`: Collection's new issuer.713       **/714      changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;715      /**716       * Create a new collection of NFTs.717       * 718       * # Permissions:719       * * Anyone - will be assigned as the issuer of the collection.720       * 721       * # Arguments:722       * - `origin`: sender of the transaction723       * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.724       * - `max`: Optional maximum number of tokens.725       * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.726       * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.727       **/728      createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;729      /**730       * Destroy a collection.731       * 732       * Only empty collections can be destroyed. If it has any tokens, they must be burned first.733       * 734       * # Permissions:735       * * Collection issuer736       * 737       * # Arguments:738       * - `origin`: sender of the transaction739       * - `collection_id`: RMRK ID of the collection to destroy.740       **/741      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;742      /**743       * "Lock" the collection and prevent new token creation. Cannot be undone.744       * 745       * # Permissions:746       * * Collection issuer747       * 748       * # Arguments:749       * - `origin`: sender of the transaction750       * - `collection_id`: RMRK ID of the collection to lock.751       **/752      lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;753      /**754       * Mint an NFT in a specified collection.755       * 756       * # Permissions:757       * * Collection issuer758       * 759       * # Arguments:760       * - `origin`: sender of the transaction761       * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).762       * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.763       * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.764       * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.765       * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.766       * - `transferable`: Can this NFT be transferred? Cannot be changed.767       * - `resources`: Resource data to be added to the NFT immediately after minting.768       **/769      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>>]>;770      /**771       * Reject an NFT sent from another account to self or owned NFT.772       * The NFT in question will not be sent back and burnt instead.773       * 774       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.775       * 776       * # Permissions:777       * - Token-owner-to-be-not778       * 779       * # Arguments:780       * - `origin`: sender of the transaction781       * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.782       * - `rmrk_nft_id`: ID of the NFT to be rejected.783       **/784      rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;785      /**786       * Remove and erase a resource from an NFT.787       * 788       * If the sender does not own the NFT, then it will be pending confirmation,789       * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.790       * 791       * # Permissions792       * - Collection issuer793       * 794       * # Arguments795       * - `origin`: sender of the transaction796       * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.797       * - `nft_id`: ID of the NFT with a resource to be removed.798       * - `resource_id`: ID of the resource to be removed.799       **/800      removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;801      /**802       * Transfer an NFT from an account/NFT A to another account/NFT B.803       * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].804       * 805       * If the target owner is an NFT owned by another account, then the NFT will enter806       * the pending state and will have to be accepted by the other account.807       * 808       * # Permissions:809       * - Token owner810       * 811       * # Arguments:812       * - `origin`: sender of the transaction813       * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.814       * - `rmrk_nft_id`: ID of the NFT to be transferred.815       * - `new_owner`: New owner of the nft which can be either an account or a NFT.816       **/817      send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;818      /**819       * Set a different order of resource priorities for an NFT. Priorities can be used,820       * for example, for order of rendering.821       * 822       * Note that the priorities are not updated automatically, and are an empty vector823       * by default. There is no pre-set definition for the order to be particular,824       * it can be interpreted arbitrarily use-case by use-case.825       * 826       * # Permissions:827       * - Token owner828       * 829       * # Arguments:830       * - `origin`: sender of the transaction831       * - `rmrk_collection_id`: RMRK collection ID of the NFT.832       * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.833       * - `priorities`: Ordered vector of resource IDs.834       **/835      setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;836      /**837       * Add or edit a custom user property, a key-value pair, describing the metadata838       * of a token or a collection, on either one of these.839       * 840       * Note that in this proxy implementation many details regarding RMRK are stored841       * as scoped properties prefixed with "rmrk:", normally inaccessible842       * to external transactions and RPCs.843       * 844       * # Permissions:845       * - Collection issuer - in case of collection property846       * - Token owner - in case of NFT property847       * 848       * # Arguments:849       * - `origin`: sender of the transaction850       * - `rmrk_collection_id`: RMRK collection ID.851       * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.852       * - `key`: Key of the custom property to be referenced by.853       * - `value`: Value of the custom property to be stored.854       **/855      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]>;856      /**857       * Generic tx858       **/859      [key: string]: SubmittableExtrinsicFunction<ApiType>;860    };861    rmrkEquip: {862      /**863       * Create a new Base.864       * 865       * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)866       * 867       * # Permissions868       * - Anyone - will be assigned as the issuer of the Base.869       * 870       * # Arguments:871       * - `origin`: Caller, will be assigned as the issuer of the Base872       * - `base_type`: Arbitrary media type, e.g. "svg".873       * - `symbol`: Arbitrary client-chosen symbol.874       * - `parts`: Array of Fixed and Slot Parts composing the Base,875       * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).876       **/877      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>]>;878      /**879       * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.880       * 881       * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).882       * 883       * # Permissions:884       * - Base issuer885       * 886       * # Arguments:887       * - `origin`: sender of the transaction888       * - `base_id`: Base containing the Slot Part to be updated.889       * - `slot_id`: Slot Part whose Equippable List is being updated .890       * - `equippables`: List of equippables that will override the current Equippables list.891       **/892      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]>;893      /**894       * Add a Theme to a Base.895       * A Theme named "default" is required prior to adding other Themes.896       * 897       * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).898       * 899       * # Permissions:900       * - Base issuer901       * 902       * # Arguments:903       * - `origin`: sender of the transaction904       * - `base_id`: Base ID containing the Theme to be updated.905       * - `theme`: Theme to add to the Base.  A Theme has a name and properties, which are an906       * array of [key, value, inherit].907       * - `key`: Arbitrary BoundedString, defined by client.908       * - `value`: Arbitrary BoundedString, defined by client.909       * - `inherit`: Optional bool.910       **/911      themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;912      /**913       * Generic tx914       **/915      [key: string]: SubmittableExtrinsicFunction<ApiType>;916    };917    session: {918      /**919       * Removes any session key(s) of the function caller.920       * 921       * This doesn't take effect until the next session.922       * 923       * The dispatch origin of this function must be Signed and the account must be either be924       * convertible to a validator ID using the chain's typical addressing system (this usually925       * means being a controller account) or directly convertible into a validator ID (which926       * usually means being a stash account).927       * 928       * # <weight>929       * - Complexity: `O(1)` in number of key types. Actual cost depends on the number of length930       * of `T::Keys::key_ids()` which is fixed.931       * - DbReads: `T::ValidatorIdOf`, `NextKeys`, `origin account`932       * - DbWrites: `NextKeys`, `origin account`933       * - DbWrites per key id: `KeyOwner`934       * # </weight>935       **/936      purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;937      /**938       * Sets the session key(s) of the function caller to `keys`.939       * Allows an account to set its session key prior to becoming a validator.940       * This doesn't take effect until the next session.941       * 942       * The dispatch origin of this function must be signed.943       * 944       * # <weight>945       * - Complexity: `O(1)`. Actual cost depends on the number of length of946       * `T::Keys::key_ids()` which is fixed.947       * - DbReads: `origin account`, `T::ValidatorIdOf`, `NextKeys`948       * - DbWrites: `origin account`, `NextKeys`949       * - DbReads per key id: `KeyOwner`950       * - DbWrites per key id: `KeyOwner`951       * # </weight>952       **/953      setKeys: AugmentedSubmittable<(keys: OpalRuntimeRuntimeCommonSessionKeys | { aura?: any } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [OpalRuntimeRuntimeCommonSessionKeys, Bytes]>;954      /**955       * Generic tx956       **/957      [key: string]: SubmittableExtrinsicFunction<ApiType>;958    };959    structure: {960      /**961       * Generic tx962       **/963      [key: string]: SubmittableExtrinsicFunction<ApiType>;964    };965    sudo: {966      /**967       * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo968       * key.969       * 970       * The dispatch origin for this call must be _Signed_.971       * 972       * # <weight>973       * - O(1).974       * - Limited storage reads.975       * - One DB change.976       * # </weight>977       **/978      setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;979      /**980       * Authenticates the sudo key and dispatches a function call with `Root` origin.981       * 982       * The dispatch origin for this call must be _Signed_.983       * 984       * # <weight>985       * - O(1).986       * - Limited storage reads.987       * - One DB write (event).988       * - Weight of derivative `call` execution + 10,000.989       * # </weight>990       **/991      sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;992      /**993       * Authenticates the sudo key and dispatches a function call with `Signed` origin from994       * a given account.995       * 996       * The dispatch origin for this call must be _Signed_.997       * 998       * # <weight>999       * - O(1).1000       * - Limited storage reads.1001       * - One DB write (event).1002       * - Weight of derivative `call` execution + 10,000.1003       * # </weight>1004       **/1005      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]>;1006      /**1007       * Authenticates the sudo key and dispatches a function call with `Root` origin.1008       * This function does not check the weight of the call, and instead allows the1009       * Sudo user to specify the weight of the call.1010       * 1011       * The dispatch origin for this call must be _Signed_.1012       * 1013       * # <weight>1014       * - O(1).1015       * - The weight of this call is defined by the caller.1016       * # </weight>1017       **/1018      sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;1019      /**1020       * Generic tx1021       **/1022      [key: string]: SubmittableExtrinsicFunction<ApiType>;1023    };1024    system: {1025      /**1026       * A dispatch that will fill the block weight up to the given ratio.1027       **/1028      fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;1029      /**1030       * Kill all storage items with a key that starts with the given prefix.1031       * 1032       * **NOTE:** We rely on the Root origin to provide us the number of subkeys under1033       * the prefix we are removing to accurately calculate the weight of this function.1034       **/1035      killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;1036      /**1037       * Kill some items from storage.1038       **/1039      killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;1040      /**1041       * Make some on-chain remark.1042       * 1043       * # <weight>1044       * - `O(1)`1045       * # </weight>1046       **/1047      remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1048      /**1049       * Make some on-chain remark and emit event.1050       **/1051      remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1052      /**1053       * Set the new runtime code.1054       * 1055       * # <weight>1056       * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`1057       * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is1058       * expensive).1059       * - 1 storage write (codec `O(C)`).1060       * - 1 digest item.1061       * - 1 event.1062       * The weight of this function is dependent on the runtime, but generally this is very1063       * expensive. We will treat this as a full block.1064       * # </weight>1065       **/1066      setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1067      /**1068       * Set the new runtime code without doing any checks of the given `code`.1069       * 1070       * # <weight>1071       * - `O(C)` where `C` length of `code`1072       * - 1 storage write (codec `O(C)`).1073       * - 1 digest item.1074       * - 1 event.1075       * The weight of this function is dependent on the runtime. We will treat this as a full1076       * block. # </weight>1077       **/1078      setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1079      /**1080       * Set the number of pages in the WebAssembly environment's heap.1081       **/1082      setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1083      /**1084       * Set some items of storage.1085       **/1086      setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;1087      /**1088       * Generic tx1089       **/1090      [key: string]: SubmittableExtrinsicFunction<ApiType>;1091    };1092    testUtils: {1093      batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;1094      enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1095      incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1096      justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1097      setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1098      setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1099      /**1100       * Generic tx1101       **/1102      [key: string]: SubmittableExtrinsicFunction<ApiType>;1103    };1104    timestamp: {1105      /**1106       * Set the current time.1107       * 1108       * This call should be invoked exactly once per block. It will panic at the finalization1109       * phase, if this call hasn't been invoked by that time.1110       * 1111       * The timestamp should be greater than the previous one by the amount specified by1112       * `MinimumPeriod`.1113       * 1114       * The dispatch origin for this call must be `Inherent`.1115       * 1116       * # <weight>1117       * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1118       * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1119       * `on_finalize`)1120       * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1121       * # </weight>1122       **/1123      set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1124      /**1125       * Generic tx1126       **/1127      [key: string]: SubmittableExtrinsicFunction<ApiType>;1128    };1129    tokens: {1130      /**1131       * Exactly as `transfer`, except the origin must be root and the source1132       * account may be specified.1133       * 1134       * The dispatch origin for this call must be _Root_.1135       * 1136       * - `source`: The sender of the transfer.1137       * - `dest`: The recipient of the transfer.1138       * - `currency_id`: currency type.1139       * - `amount`: free balance amount to tranfer.1140       **/1141      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>]>;1142      /**1143       * Set the balances of a given account.1144       * 1145       * This will alter `FreeBalance` and `ReservedBalance` in storage. it1146       * will also decrease the total issuance of the system1147       * (`TotalIssuance`). If the new free or reserved balance is below the1148       * existential deposit, it will reap the `AccountInfo`.1149       * 1150       * The dispatch origin for this call is `root`.1151       **/1152      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>]>;1153      /**1154       * Transfer some liquid free balance to another account.1155       * 1156       * `transfer` will set the `FreeBalance` of the sender and receiver.1157       * It will decrease the total issuance of the system by the1158       * `TransferFee`. If the sender's account is below the existential1159       * deposit as a result of the transfer, the account will be reaped.1160       * 1161       * The dispatch origin for this call must be `Signed` by the1162       * transactor.1163       * 1164       * - `dest`: The recipient of the transfer.1165       * - `currency_id`: currency type.1166       * - `amount`: free balance amount to tranfer.1167       **/1168      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>]>;1169      /**1170       * Transfer all remaining balance to the given account.1171       * 1172       * NOTE: This function only attempts to transfer _transferable_1173       * balances. This means that any locked, reserved, or existential1174       * deposits (when `keep_alive` is `true`), will not be transferred by1175       * this function. To ensure that this function results in a killed1176       * account, you might need to prepare the account by removing any1177       * reference counters, storage deposits, etc...1178       * 1179       * The dispatch origin for this call must be `Signed` by the1180       * transactor.1181       * 1182       * - `dest`: The recipient of the transfer.1183       * - `currency_id`: currency type.1184       * - `keep_alive`: A boolean to determine if the `transfer_all`1185       * operation should send all of the funds the account has, causing1186       * the sender account to be killed (false), or transfer everything1187       * except at least the existential deposit, which will guarantee to1188       * keep the sender account alive (true).1189       **/1190      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]>;1191      /**1192       * Same as the [`transfer`] call, but with a check that the transfer1193       * will not kill the origin account.1194       * 1195       * 99% of the time you want [`transfer`] instead.1196       * 1197       * The dispatch origin for this call must be `Signed` by the1198       * transactor.1199       * 1200       * - `dest`: The recipient of the transfer.1201       * - `currency_id`: currency type.1202       * - `amount`: free balance amount to tranfer.1203       **/1204      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>]>;1205      /**1206       * Generic tx1207       **/1208      [key: string]: SubmittableExtrinsicFunction<ApiType>;1209    };1210    treasury: {1211      /**1212       * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1213       * and the original deposit will be returned.1214       * 1215       * May only be called from `T::ApproveOrigin`.1216       * 1217       * # <weight>1218       * - Complexity: O(1).1219       * - DbReads: `Proposals`, `Approvals`1220       * - DbWrite: `Approvals`1221       * # </weight>1222       **/1223      approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1224      /**1225       * Put forward a suggestion for spending. A deposit proportional to the value1226       * is reserved and slashed if the proposal is rejected. It is returned once the1227       * proposal is awarded.1228       * 1229       * # <weight>1230       * - Complexity: O(1)1231       * - DbReads: `ProposalCount`, `origin account`1232       * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1233       * # </weight>1234       **/1235      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]>;1236      /**1237       * Reject a proposed spend. The original deposit will be slashed.1238       * 1239       * May only be called from `T::RejectOrigin`.1240       * 1241       * # <weight>1242       * - Complexity: O(1)1243       * - DbReads: `Proposals`, `rejected proposer account`1244       * - DbWrites: `Proposals`, `rejected proposer account`1245       * # </weight>1246       **/1247      rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1248      /**1249       * Force a previously approved proposal to be removed from the approval queue.1250       * The original deposit will no longer be returned.1251       * 1252       * May only be called from `T::RejectOrigin`.1253       * - `proposal_id`: The index of a proposal1254       * 1255       * # <weight>1256       * - Complexity: O(A) where `A` is the number of approvals1257       * - Db reads and writes: `Approvals`1258       * # </weight>1259       * 1260       * Errors:1261       * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1262       * i.e., the proposal has not been approved. This could also mean the proposal does not1263       * exist altogether, thus there is no way it would have been approved in the first place.1264       **/1265      removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1266      /**1267       * Propose and approve a spend of treasury funds.1268       * 1269       * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1270       * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1271       * - `beneficiary`: The destination account for the transfer.1272       * 1273       * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1274       * beneficiary.1275       **/1276      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]>;1277      /**1278       * Generic tx1279       **/1280      [key: string]: SubmittableExtrinsicFunction<ApiType>;1281    };1282    unique: {1283      /**1284       * Add an admin to a collection.1285       * 1286       * NFT Collection can be controlled by multiple admin addresses1287       * (some which can also be servers, for example). Admins can issue1288       * and burn NFTs, as well as add and remove other admins,1289       * but cannot change NFT or Collection ownership.1290       * 1291       * # Permissions1292       * 1293       * * Collection owner1294       * * Collection admin1295       * 1296       * # Arguments1297       * 1298       * * `collection_id`: ID of the Collection to add an admin for.1299       * * `new_admin`: Address of new admin to add.1300       **/1301      addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1302      /**1303       * Add an address to allow list.1304       * 1305       * # Permissions1306       * 1307       * * Collection owner1308       * * Collection admin1309       * 1310       * # Arguments1311       * 1312       * * `collection_id`: ID of the modified collection.1313       * * `address`: ID of the address to be added to the allowlist.1314       **/1315      addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1316      /**1317       * Allow a non-permissioned address to transfer or burn an item.1318       * 1319       * # Permissions1320       * 1321       * * Collection owner1322       * * Collection admin1323       * * Current item owner1324       * 1325       * # Arguments1326       * 1327       * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1328       * * `collection_id`: ID of the collection the item belongs to.1329       * * `item_id`: ID of the item transactions on which are now approved.1330       * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1331       * Set to 0 to revoke the approval.1332       **/1333      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]>;1334      /**1335       * Destroy a token on behalf of the owner as a non-owner account.1336       * 1337       * See also: [`approve`][`Pallet::approve`].1338       * 1339       * After this method executes, one approval is removed from the total so that1340       * the approved address will not be able to transfer this item again from this owner.1341       * 1342       * # Permissions1343       * 1344       * * Collection owner1345       * * Collection admin1346       * * Current token owner1347       * * Address approved by current item owner1348       * 1349       * # Arguments1350       * 1351       * * `from`: The owner of the burning item.1352       * * `collection_id`: ID of the collection to which the item belongs.1353       * * `item_id`: ID of item to burn.1354       * * `value`: Number of pieces to burn.1355       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1356       * * Fungible Mode: The desired number of pieces to burn.1357       * * Re-Fungible Mode: The desired number of pieces to burn.1358       **/1359      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]>;1360      /**1361       * Destroy an item.1362       * 1363       * # Permissions1364       * 1365       * * Collection owner1366       * * Collection admin1367       * * Current item owner1368       * 1369       * # Arguments1370       * 1371       * * `collection_id`: ID of the collection to which the item belongs.1372       * * `item_id`: ID of item to burn.1373       * * `value`: Number of pieces of the item to destroy.1374       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1375       * * Fungible Mode: The desired number of pieces to burn.1376       * * Re-Fungible Mode: The desired number of pieces to burn.1377       **/1378      burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1379      /**1380       * Change the owner of the collection.1381       * 1382       * # Permissions1383       * 1384       * * Collection owner1385       * 1386       * # Arguments1387       * 1388       * * `collection_id`: ID of the modified collection.1389       * * `new_owner`: ID of the account that will become the owner.1390       **/1391      changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1392      /**1393       * Confirm own sponsorship of a collection, becoming the sponsor.1394       * 1395       * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1396       * Sponsor can pay the fees of a transaction instead of the sender,1397       * but only within specified limits.1398       * 1399       * # Permissions1400       * 1401       * * Sponsor-to-be1402       * 1403       * # Arguments1404       * 1405       * * `collection_id`: ID of the collection with the pending sponsor.1406       **/1407      confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1408      /**1409       * Create a collection of tokens.1410       * 1411       * Each Token may have multiple properties encoded as an array of bytes1412       * of certain length. The initial owner of the collection is set1413       * to the address that signed the transaction and can be changed later.1414       * 1415       * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1416       * 1417       * # Permissions1418       * 1419       * * Anyone - becomes the owner of the new collection.1420       * 1421       * # Arguments1422       * 1423       * * `collection_name`: Wide-character string with collection name1424       * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1425       * * `collection_description`: Wide-character string with collection description1426       * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1427       * * `token_prefix`: Byte string containing the token prefix to mark a collection1428       * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1429       * * `mode`: Type of items stored in the collection and type dependent data.1430       **/1431      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]>;1432      /**1433       * Create a collection with explicit parameters.1434       * 1435       * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1436       * 1437       * # Permissions1438       * 1439       * * Anyone - becomes the owner of the new collection.1440       * 1441       * # Arguments1442       * 1443       * * `data`: Explicit data of a collection used for its creation.1444       **/1445      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]>;1446      /**1447       * Mint an item within a collection.1448       * 1449       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1450       * 1451       * # Permissions1452       * 1453       * * Collection owner1454       * * Collection admin1455       * * Anyone if1456       * * Allow List is enabled, and1457       * * Address is added to allow list, and1458       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1459       * 1460       * # Arguments1461       * 1462       * * `collection_id`: ID of the collection to which an item would belong.1463       * * `owner`: Address of the initial owner of the item.1464       * * `data`: Token data describing the item to store on chain.1465       **/1466      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]>;1467      /**1468       * Create multiple items within a collection.1469       * 1470       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1471       * 1472       * # Permissions1473       * 1474       * * Collection owner1475       * * Collection admin1476       * * Anyone if1477       * * Allow List is enabled, and1478       * * Address is added to the allow list, and1479       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1480       * 1481       * # Arguments1482       * 1483       * * `collection_id`: ID of the collection to which the tokens would belong.1484       * * `owner`: Address of the initial owner of the tokens.1485       * * `items_data`: Vector of data describing each item to be created.1486       **/1487      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>]>;1488      /**1489       * Create multiple items within a collection with explicitly specified initial parameters.1490       * 1491       * # Permissions1492       * 1493       * * Collection owner1494       * * Collection admin1495       * * Anyone if1496       * * Allow List is enabled, and1497       * * Address is added to allow list, and1498       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1499       * 1500       * # Arguments1501       * 1502       * * `collection_id`: ID of the collection to which the tokens would belong.1503       * * `data`: Explicit item creation data.1504       **/1505      createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1506      /**1507       * Delete specified collection properties.1508       * 1509       * # Permissions1510       * 1511       * * Collection Owner1512       * * Collection Admin1513       * 1514       * # Arguments1515       * 1516       * * `collection_id`: ID of the modified collection.1517       * * `property_keys`: Vector of keys of the properties to be deleted.1518       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1519       **/1520      deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1521      /**1522       * Delete specified token properties. Currently properties only work with NFTs.1523       * 1524       * # Permissions1525       * 1526       * * Depends on collection's token property permissions and specified property mutability:1527       * * Collection owner1528       * * Collection admin1529       * * Token owner1530       * 1531       * # Arguments1532       * 1533       * * `collection_id`: ID of the collection to which the token belongs.1534       * * `token_id`: ID of the modified token.1535       * * `property_keys`: Vector of keys of the properties to be deleted.1536       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1537       **/1538      deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1539      /**1540       * Destroy a collection if no tokens exist within.1541       * 1542       * # Permissions1543       * 1544       * * Collection owner1545       * 1546       * # Arguments1547       * 1548       * * `collection_id`: Collection to destroy.1549       **/1550      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1551      /**1552       * Repairs a collection if the data was somehow corrupted.1553       * 1554       * # Arguments1555       * 1556       * * `collection_id`: ID of the collection to repair.1557       **/1558      forceRepairCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1559      /**1560       * Repairs a token if the data was somehow corrupted.1561       * 1562       * # Arguments1563       * 1564       * * `collection_id`: ID of the collection the item belongs to.1565       * * `item_id`: ID of the item.1566       **/1567      forceRepairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1568      /**1569       * Remove admin of a collection.1570       * 1571       * An admin address can remove itself. List of admins may become empty,1572       * in which case only Collection Owner will be able to add an Admin.1573       * 1574       * # Permissions1575       * 1576       * * Collection owner1577       * * Collection admin1578       * 1579       * # Arguments1580       * 1581       * * `collection_id`: ID of the collection to remove the admin for.1582       * * `account_id`: Address of the admin to remove.1583       **/1584      removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1585      /**1586       * Remove a collection's a sponsor, making everyone pay for their own transactions.1587       * 1588       * # Permissions1589       * 1590       * * Collection owner1591       * 1592       * # Arguments1593       * 1594       * * `collection_id`: ID of the collection with the sponsor to remove.1595       **/1596      removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1597      /**1598       * Remove an address from allow list.1599       * 1600       * # Permissions1601       * 1602       * * Collection owner1603       * * Collection admin1604       * 1605       * # Arguments1606       * 1607       * * `collection_id`: ID of the modified collection.1608       * * `address`: ID of the address to be removed from the allowlist.1609       **/1610      removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1611      /**1612       * Re-partition a refungible token, while owning all of its parts/pieces.1613       * 1614       * # Permissions1615       * 1616       * * Token owner (must own every part)1617       * 1618       * # Arguments1619       * 1620       * * `collection_id`: ID of the collection the RFT belongs to.1621       * * `token_id`: ID of the RFT.1622       * * `amount`: New number of parts/pieces into which the token shall be partitioned.1623       **/1624      repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1625      /**1626       * Sets or unsets the approval of a given operator.1627       * 1628       * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1629       * 1630       * # Arguments1631       * 1632       * * `owner`: Token owner1633       * * `operator`: Operator1634       * * `approve`: Should operator status be granted or revoked?1635       **/1636      setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1637      /**1638       * Set specific limits of a collection. Empty, or None fields mean chain default.1639       * 1640       * # Permissions1641       * 1642       * * Collection owner1643       * * Collection admin1644       * 1645       * # Arguments1646       * 1647       * * `collection_id`: ID of the modified collection.1648       * * `new_limit`: New limits of the collection. Fields that are not set (None)1649       * will not overwrite the old ones.1650       **/1651      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]>;1652      /**1653       * Set specific permissions of a collection. Empty, or None fields mean chain default.1654       * 1655       * # Permissions1656       * 1657       * * Collection owner1658       * * Collection admin1659       * 1660       * # Arguments1661       * 1662       * * `collection_id`: ID of the modified collection.1663       * * `new_permission`: New permissions of the collection. Fields that are not set (None)1664       * will not overwrite the old ones.1665       **/1666      setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1667      /**1668       * Add or change collection properties.1669       * 1670       * # Permissions1671       * 1672       * * Collection owner1673       * * Collection admin1674       * 1675       * # Arguments1676       * 1677       * * `collection_id`: ID of the modified collection.1678       * * `properties`: Vector of key-value pairs stored as the collection's metadata.1679       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1680       **/1681      setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1682      /**1683       * Set (invite) a new collection sponsor.1684       * 1685       * If successful, confirmation from the sponsor-to-be will be pending.1686       * 1687       * # Permissions1688       * 1689       * * Collection owner1690       * * Collection admin1691       * 1692       * # Arguments1693       * 1694       * * `collection_id`: ID of the modified collection.1695       * * `new_sponsor`: ID of the account of the sponsor-to-be.1696       **/1697      setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1698      /**1699       * Add or change token properties according to collection's permissions.1700       * Currently properties only work with NFTs.1701       * 1702       * # Permissions1703       * 1704       * * Depends on collection's token property permissions and specified property mutability:1705       * * Collection owner1706       * * Collection admin1707       * * Token owner1708       * 1709       * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1710       * 1711       * # Arguments1712       * 1713       * * `collection_id: ID of the collection to which the token belongs.1714       * * `token_id`: ID of the modified token.1715       * * `properties`: Vector of key-value pairs stored as the token's metadata.1716       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1717       **/1718      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>]>;1719      /**1720       * Add or change token property permissions of a collection.1721       * 1722       * Without a permission for a particular key, a property with that key1723       * cannot be created in a token.1724       * 1725       * # Permissions1726       * 1727       * * Collection owner1728       * * Collection admin1729       * 1730       * # Arguments1731       * 1732       * * `collection_id`: ID of the modified collection.1733       * * `property_permissions`: Vector of permissions for property keys.1734       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1735       **/1736      setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1737      /**1738       * Completely allow or disallow transfers for a particular collection.1739       * 1740       * # Permissions1741       * 1742       * * Collection owner1743       * 1744       * # Arguments1745       * 1746       * * `collection_id`: ID of the collection.1747       * * `value`: New value of the flag, are transfers allowed?1748       **/1749      setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1750      /**1751       * Change ownership of the token.1752       * 1753       * # Permissions1754       * 1755       * * Collection owner1756       * * Collection admin1757       * * Current token owner1758       * 1759       * # Arguments1760       * 1761       * * `recipient`: Address of token recipient.1762       * * `collection_id`: ID of the collection the item belongs to.1763       * * `item_id`: ID of the item.1764       * * Non-Fungible Mode: Required.1765       * * Fungible Mode: Ignored.1766       * * Re-Fungible Mode: Required.1767       * 1768       * * `value`: Amount to transfer.1769       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1770       * * Fungible Mode: The desired number of pieces to transfer.1771       * * Re-Fungible Mode: The desired number of pieces to transfer.1772       **/1773      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]>;1774      /**1775       * Change ownership of an item on behalf of the owner as a non-owner account.1776       * 1777       * See the [`approve`][`Pallet::approve`] method for additional information.1778       * 1779       * After this method executes, one approval is removed from the total so that1780       * the approved address will not be able to transfer this item again from this owner.1781       * 1782       * # Permissions1783       * 1784       * * Collection owner1785       * * Collection admin1786       * * Current item owner1787       * * Address approved by current item owner1788       * 1789       * # Arguments1790       * 1791       * * `from`: Address that currently owns the token.1792       * * `recipient`: Address of the new token-owner-to-be.1793       * * `collection_id`: ID of the collection the item.1794       * * `item_id`: ID of the item to be transferred.1795       * * `value`: Amount to transfer.1796       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1797       * * Fungible Mode: The desired number of pieces to transfer.1798       * * Re-Fungible Mode: The desired number of pieces to transfer.1799       **/1800      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]>;1801      /**1802       * Generic tx1803       **/1804      [key: string]: SubmittableExtrinsicFunction<ApiType>;1805    };1806    vesting: {1807      claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1808      claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1809      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>]>;1810      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]>;1811      /**1812       * Generic tx1813       **/1814      [key: string]: SubmittableExtrinsicFunction<ApiType>;1815    };1816    xcmpQueue: {1817      /**1818       * Resumes all XCM executions for the XCMP queue.1819       * 1820       * Note that this function doesn't change the status of the in/out bound channels.1821       * 1822       * - `origin`: Must pass `ControllerOrigin`.1823       **/1824      resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1825      /**1826       * Services a single overweight XCM.1827       * 1828       * - `origin`: Must pass `ExecuteOverweightOrigin`.1829       * - `index`: The index of the overweight XCM to service1830       * - `weight_limit`: The amount of weight that XCM execution may take.1831       * 1832       * Errors:1833       * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1834       * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1835       * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1836       * 1837       * Events:1838       * - `OverweightServiced`: On success.1839       **/1840      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1841      /**1842       * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1843       * 1844       * - `origin`: Must pass `ControllerOrigin`.1845       **/1846      suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1847      /**1848       * Overwrites the number of pages of messages which must be in the queue after which we drop any further1849       * messages from the channel.1850       * 1851       * - `origin`: Must pass `Root`.1852       * - `new`: Desired value for `QueueConfigData.drop_threshold`1853       **/1854      updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1855      /**1856       * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1857       * message sending may recommence after it has been suspended.1858       * 1859       * - `origin`: Must pass `Root`.1860       * - `new`: Desired value for `QueueConfigData.resume_threshold`1861       **/1862      updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1863      /**1864       * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1865       * suspend their sending.1866       * 1867       * - `origin`: Must pass `Root`.1868       * - `new`: Desired value for `QueueConfigData.suspend_value`1869       **/1870      updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1871      /**1872       * Overwrites the amount of remaining weight under which we stop processing messages.1873       * 1874       * - `origin`: Must pass `Root`.1875       * - `new`: Desired value for `QueueConfigData.threshold_weight`1876       **/1877      updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1878      /**1879       * Overwrites the speed to which the available weight approaches the maximum weight.1880       * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1881       * 1882       * - `origin`: Must pass `Root`.1883       * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1884       **/1885      updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1886      /**1887       * Overwrite the maximum amount of weight any individual message may consume.1888       * Messages above this weight go into the overweight queue and may only be serviced explicitly.1889       * 1890       * - `origin`: Must pass `Root`.1891       * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1892       **/1893      updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1894      /**1895       * Generic tx1896       **/1897      [key: string]: SubmittableExtrinsicFunction<ApiType>;1898    };1899    xTokens: {1900      /**1901       * Transfer native currencies.1902       * 1903       * `dest_weight_limit` is the weight for XCM execution on the dest1904       * chain, and it would be charged from the transferred assets. If set1905       * below requirements, the execution may fail and assets wouldn't be1906       * received.1907       * 1908       * It's a no-op if any error on local XCM execution or message sending.1909       * Note sending assets out per se doesn't guarantee they would be1910       * received. Receiving depends on if the XCM message could be delivered1911       * by the network, and if the receiving chain would handle1912       * messages correctly.1913       **/1914      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]>;1915      /**1916       * Transfer `MultiAsset`.1917       * 1918       * `dest_weight_limit` is the weight for XCM execution on the dest1919       * chain, and it would be charged from the transferred assets. If set1920       * below requirements, the execution may fail and assets wouldn't be1921       * received.1922       * 1923       * It's a no-op if any error on local XCM execution or message sending.1924       * Note sending assets out per se doesn't guarantee they would be1925       * received. Receiving depends on if the XCM message could be delivered1926       * by the network, and if the receiving chain would handle1927       * messages correctly.1928       **/1929      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]>;1930      /**1931       * Transfer several `MultiAsset` specifying the item to be used as fee1932       * 1933       * `dest_weight_limit` is the weight for XCM execution on the dest1934       * chain, and it would be charged from the transferred assets. If set1935       * below requirements, the execution may fail and assets wouldn't be1936       * received.1937       * 1938       * `fee_item` is index of the MultiAssets that we want to use for1939       * payment1940       * 1941       * It's a no-op if any error on local XCM execution or message sending.1942       * Note sending assets out per se doesn't guarantee they would be1943       * received. Receiving depends on if the XCM message could be delivered1944       * by the network, and if the receiving chain would handle1945       * messages correctly.1946       **/1947      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]>;1948      /**1949       * Transfer `MultiAsset` specifying the fee and amount as separate.1950       * 1951       * `dest_weight_limit` is the weight for XCM execution on the dest1952       * chain, and it would be charged from the transferred assets. If set1953       * below requirements, the execution may fail and assets wouldn't be1954       * received.1955       * 1956       * `fee` is the multiasset to be spent to pay for execution in1957       * destination chain. Both fee and amount will be subtracted form the1958       * callers balance For now we only accept fee and asset having the same1959       * `MultiLocation` id.1960       * 1961       * If `fee` is not high enough to cover for the execution costs in the1962       * destination chain, then the assets will be trapped in the1963       * destination chain1964       * 1965       * It's a no-op if any error on local XCM execution or message sending.1966       * Note sending assets out per se doesn't guarantee they would be1967       * received. Receiving depends on if the XCM message could be delivered1968       * by the network, and if the receiving chain would handle1969       * messages correctly.1970       **/1971      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]>;1972      /**1973       * Transfer several currencies specifying the item to be used as fee1974       * 1975       * `dest_weight_limit` is the weight for XCM execution on the dest1976       * chain, and it would be charged from the transferred assets. If set1977       * below requirements, the execution may fail and assets wouldn't be1978       * received.1979       * 1980       * `fee_item` is index of the currencies tuple that we want to use for1981       * payment1982       * 1983       * It's a no-op if any error on local XCM execution or message sending.1984       * Note sending assets out per se doesn't guarantee they would be1985       * received. Receiving depends on if the XCM message could be delivered1986       * by the network, and if the receiving chain would handle1987       * messages correctly.1988       **/1989      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]>;1990      /**1991       * Transfer native currencies specifying the fee and amount as1992       * separate.1993       * 1994       * `dest_weight_limit` is the weight for XCM execution on the dest1995       * chain, and it would be charged from the transferred assets. If set1996       * below requirements, the execution may fail and assets wouldn't be1997       * received.1998       * 1999       * `fee` is the amount to be spent to pay for execution in destination2000       * chain. Both fee and amount will be subtracted form the callers2001       * balance.2002       * 2003       * If `fee` is not high enough to cover for the execution costs in the2004       * destination chain, then the assets will be trapped in the2005       * destination chain2006       * 2007       * It's a no-op if any error on local XCM execution or message sending.2008       * Note sending assets out per se doesn't guarantee they would be2009       * received. Receiving depends on if the XCM message could be delivered2010       * by the network, and if the receiving chain would handle2011       * messages correctly.2012       **/2013      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]>;2014      /**2015       * Generic tx2016       **/2017      [key: string]: SubmittableExtrinsicFunction<ApiType>;2018    };2019  } // AugmentedSubmittables2020} // declare module