git.delta.rocks / unique-network / refs/commits / 992dc8a7b061

1// Auto-generated via `yarn polkadot-types-from-chain`, do not edit2/* eslint-disable */34// import type lookup before we augment - in some environments5// this is required to allow for ambient/previous definitions6import '@polkadot/api-base/types/submittable';78import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types';9import type { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';10import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';11<<<<<<< HEAD12import type { AccountId32, Call, H160, H256, MultiAddress, Permill } from '@polkadot/types/interfaces/runtime';13=======14<<<<<<< HEAD15import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill } from '@polkadot/types/interfaces/runtime';16>>>>>>> chore:  regenerate types17import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumLog, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletConfigurationAppPromotionConfiguration, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, SpWeightsWeightV2Weight, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';18=======19import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill, Weight } from '@polkadot/types/interfaces/runtime';20import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumLog, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';21<<<<<<< HEAD22=======23import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';24>>>>>>> chore:  regenerate types25>>>>>>> chore:  regenerate types26=======27>>>>>>> fix: regenerate types after rebase2829export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;30export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;31export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;3233declare module '@polkadot/api-base/types/submittable' {34  interface AugmentedSubmittables<ApiType extends ApiTypes> {35    appPromotion: {36      /**37       * Recalculates interest for the specified number of stakers.38       * If all stakers are not recalculated, the next call of the extrinsic39       * will continue the recalculation, from those stakers for whom this40       * was not perform in last call.41       * 42       * # Permissions43       * 44       * * Pallet admin45       * 46       * # Arguments47       * 48       * * `stakers_number`: the number of stakers for which recalculation will be performed49       **/50      payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;51      /**52       * Sets an address as the the admin.53       * 54       * # Permissions55       * 56       * * Sudo57       * 58       * # Arguments59       * 60       * * `admin`: account of the new admin.61       **/62      setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;63      /**64       * Sets the pallet to be the sponsor for the collection.65       * 66       * # Permissions67       * 68       * * Pallet admin69       * 70       * # Arguments71       * 72       * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`73       **/74      sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;75      /**76       * Sets the pallet to be the sponsor for the contract.77       * 78       * # Permissions79       * 80       * * Pallet admin81       * 82       * # Arguments83       * 84       * * `contract_id`: the contract address that will be sponsored by `pallet_id`85       **/86      sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;87      /**88       * Stakes the amount of native tokens.89       * Sets `amount` to the locked state.90       * The maximum number of stakes for a staker is 10.91       * 92       * # Arguments93       * 94       * * `amount`: in native tokens.95       **/96      stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;97      /**98       * Removes the pallet as the sponsor for the collection.99       * Returns [`NoPermission`][`Error::NoPermission`]100       * if the pallet wasn't the sponsor.101       * 102       * # Permissions103       * 104       * * Pallet admin105       * 106       * # Arguments107       * 108       * * `collection_id`: ID of the collection that is sponsored by `pallet_id`109       **/110      stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;111      /**112       * Removes the pallet as the sponsor for the contract.113       * Returns [`NoPermission`][`Error::NoPermission`]114       * if the pallet wasn't the sponsor.115       * 116       * # Permissions117       * 118       * * Pallet admin119       * 120       * # Arguments121       * 122       * * `contract_id`: the contract address that is sponsored by `pallet_id`123       **/124      stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;125      /**126       * Unstakes all stakes.127       * Moves the sum of all stakes to the `reserved` state.128       * After the end of `PendingInterval` this sum becomes completely129       * free for further use.130       **/131      unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;132      /**133       * Generic tx134       **/135      [key: string]: SubmittableExtrinsicFunction<ApiType>;136    };137    balances: {138      /**139       * Exactly as `transfer`, except the origin must be root and the source account may be140       * specified.141       * # <weight>142       * - Same as transfer, but additional read and write because the source account is not143       * assumed to be in the overlay.144       * # </weight>145       **/146      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>]>;147      /**148       * Unreserve some balance from a user by force.149       * 150       * Can only be called by ROOT.151       **/152      forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;153      /**154       * Set the balances of a given account.155       * 156       * This will alter `FreeBalance` and `ReservedBalance` in storage. it will157       * also alter the total issuance of the system (`TotalIssuance`) appropriately.158       * If the new free or reserved balance is below the existential deposit,159       * it will reset the account nonce (`frame_system::AccountNonce`).160       * 161       * The dispatch origin for this call is `root`.162       **/163      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>]>;164      /**165       * Transfer some liquid free balance to another account.166       * 167       * `transfer` will set the `FreeBalance` of the sender and receiver.168       * If the sender's account is below the existential deposit as a result169       * of the transfer, the account will be reaped.170       * 171       * The dispatch origin for this call must be `Signed` by the transactor.172       * 173       * # <weight>174       * - Dependent on arguments but not critical, given proper implementations for input config175       * types. See related functions below.176       * - It contains a limited number of reads and writes internally and no complex177       * computation.178       * 179       * Related functions:180       * 181       * - `ensure_can_withdraw` is always called internally but has a bounded complexity.182       * - Transferring balances to accounts that did not exist before will cause183       * `T::OnNewAccount::on_new_account` to be called.184       * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.185       * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check186       * that the transfer will not kill the origin account.187       * ---------------------------------188       * - Origin account is already in memory, so no DB operations for them.189       * # </weight>190       **/191      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>]>;192      /**193       * Transfer the entire transferable balance from the caller account.194       * 195       * NOTE: This function only attempts to transfer _transferable_ balances. This means that196       * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be197       * transferred by this function. To ensure that this function results in a killed account,198       * you might need to prepare the account by removing any reference counters, storage199       * deposits, etc...200       * 201       * The dispatch origin of this call must be Signed.202       * 203       * - `dest`: The recipient of the transfer.204       * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all205       * of the funds the account has, causing the sender account to be killed (false), or206       * transfer everything except at least the existential deposit, which will guarantee to207       * keep the sender account alive (true). # <weight>208       * - O(1). Just like transfer, but reading the user's transferable balance first.209       * #</weight>210       **/211      transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;212      /**213       * Same as the [`transfer`] call, but with a check that the transfer will not kill the214       * origin account.215       * 216       * 99% of the time you want [`transfer`] instead.217       * 218       * [`transfer`]: struct.Pallet.html#method.transfer219       **/220      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>]>;221      /**222       * Generic tx223       **/224      [key: string]: SubmittableExtrinsicFunction<ApiType>;225    };226    charging: {227      /**228       * Generic tx229       **/230      [key: string]: SubmittableExtrinsicFunction<ApiType>;231    };232    configuration: {233      setAppPromotionConfigurationOverride: AugmentedSubmittable<(configuration: PalletConfigurationAppPromotionConfiguration | { recalculationInterval?: any; pendingInterval?: any; intervalIncome?: any; maxStakersPerCalculation?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletConfigurationAppPromotionConfiguration]>;234      setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;235      setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;236      setXcmAllowedLocations: AugmentedSubmittable<(locations: Option<Vec<XcmV1MultiLocation>> | null | Uint8Array | Vec<XcmV1MultiLocation> | (XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<Vec<XcmV1MultiLocation>>]>;237      /**238       * Generic tx239       **/240      [key: string]: SubmittableExtrinsicFunction<ApiType>;241    };242    cumulusXcm: {243      /**244       * Generic tx245       **/246      [key: string]: SubmittableExtrinsicFunction<ApiType>;247    };248    dmpQueue: {249      /**250       * Service a single overweight message.251       * 252       * - `origin`: Must pass `ExecuteOverweightOrigin`.253       * - `index`: The index of the overweight message to service.254       * - `weight_limit`: The amount of weight that message execution may take.255       * 256       * Errors:257       * - `Unknown`: Message of `index` is unknown.258       * - `OverLimit`: Message execution may use greater than `weight_limit`.259       * 260       * Events:261       * - `OverweightServiced`: On success.262       **/263      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;264      /**265       * Generic tx266       **/267      [key: string]: SubmittableExtrinsicFunction<ApiType>;268    };269    ethereum: {270      /**271       * Transact an Ethereum transaction.272       **/273      transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;274      /**275       * Generic tx276       **/277      [key: string]: SubmittableExtrinsicFunction<ApiType>;278    };279    evm: {280      /**281       * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.282       **/283      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>]>>]>;284      /**285       * Issue an EVM create operation. This is similar to a contract creation transaction in286       * Ethereum.287       **/288      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>]>>]>;289      /**290       * Issue an EVM create2 operation.291       **/292      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>]>>]>;293      /**294       * Withdraw balance from EVM into currency/balances pallet.295       **/296      withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;297      /**298       * Generic tx299       **/300      [key: string]: SubmittableExtrinsicFunction<ApiType>;301    };302    evmMigration: {303      /**304       * Start contract migration, inserts contract stub at target address,305       * and marks account as pending, allowing to insert storage306       **/307      begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;308      /**309       * Finish contract migration, allows it to be called.310       * It is not possible to alter contract storage via [`Self::set_data`]311       * after this call.312       **/313      finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;314      /**315       * Create ethereum events attached to the fake transaction316       **/317      insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;318      /**319       * Create substrate events320       **/321      insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;322      /**323       * Insert items into contract storage, this method can be called324       * multiple times325       **/326      setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;327      /**328       * Generic tx329       **/330      [key: string]: SubmittableExtrinsicFunction<ApiType>;331    };332    foreignAssets: {333      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]>;334      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]>;335      /**336       * Generic tx337       **/338      [key: string]: SubmittableExtrinsicFunction<ApiType>;339    };340    inflation: {341      /**342       * This method sets the inflation start date. Can be only called once.343       * Inflation start block can be backdated and will catch up. The method will create Treasury344       * account if it does not exist and perform the first inflation deposit.345       * 346       * # Permissions347       * 348       * * Root349       * 350       * # Arguments351       * 352       * * inflation_start_relay_block: The relay chain block at which inflation should start353       **/354      startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;355      /**356       * Generic tx357       **/358      [key: string]: SubmittableExtrinsicFunction<ApiType>;359    };360    maintenance: {361      disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;362      enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;363      /**364       * Generic tx365       **/366      [key: string]: SubmittableExtrinsicFunction<ApiType>;367    };368    parachainSystem: {369      authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;370      enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;371      /**372       * Set the current validation data.373       * 374       * This should be invoked exactly once per block. It will panic at the finalization375       * phase if the call was not invoked.376       * 377       * The dispatch origin for this call must be `Inherent`378       * 379       * As a side effect, this function upgrades the current validation function380       * if the appropriate time has come.381       **/382      setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;383      sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;384      /**385       * Generic tx386       **/387      [key: string]: SubmittableExtrinsicFunction<ApiType>;388    };389    polkadotXcm: {390      /**391       * Execute an XCM message from a local, signed, origin.392       * 393       * An event is deposited indicating whether `msg` could be executed completely or only394       * partially.395       * 396       * No more than `max_weight` will be used in its attempted execution. If this is less than the397       * maximum amount of weight that the message could take to be executed, then no execution398       * attempt will be made.399       * 400       * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully401       * to completion; only that *some* of it was executed.402       **/403      execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;404      /**405       * Set a safe XCM version (the version that XCM should be encoded with if the most recent406       * version a destination can accept is unknown).407       * 408       * - `origin`: Must be Root.409       * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.410       **/411      forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;412      /**413       * Ask a location to notify us regarding their XCM version and any changes to it.414       * 415       * - `origin`: Must be Root.416       * - `location`: The location to which we should subscribe for XCM version notifications.417       **/418      forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;419      /**420       * Require that a particular destination should no longer notify us regarding any XCM421       * version changes.422       * 423       * - `origin`: Must be Root.424       * - `location`: The location to which we are currently subscribed for XCM version425       * notifications which we no longer desire.426       **/427      forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;428      /**429       * Extoll that a particular destination can be communicated with through a particular430       * version of XCM.431       * 432       * - `origin`: Must be Root.433       * - `location`: The destination that is being described.434       * - `xcm_version`: The latest version of XCM that `location` supports.435       **/436      forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;437      /**438       * Transfer some assets from the local chain to the sovereign account of a destination439       * chain and forward a notification XCM.440       * 441       * Fee payment on the destination side is made from the asset in the `assets` vector of442       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight443       * is needed than `weight_limit`, then the operation will fail and the assets send may be444       * at risk.445       * 446       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.447       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send448       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.449       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be450       * an `AccountId32` value.451       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the452       * `dest` side.453       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay454       * fees.455       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.456       **/457      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]>;458      /**459       * Teleport some assets from the local chain to some destination chain.460       * 461       * Fee payment on the destination side is made from the asset in the `assets` vector of462       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight463       * is needed than `weight_limit`, then the operation will fail and the assets send may be464       * at risk.465       * 466       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.467       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send468       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.469       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be470       * an `AccountId32` value.471       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the472       * `dest` side. May not be empty.473       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay474       * fees.475       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.476       **/477      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]>;478      /**479       * Transfer some assets from the local chain to the sovereign account of a destination480       * chain and forward a notification XCM.481       * 482       * Fee payment on the destination side is made from the asset in the `assets` vector of483       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,484       * with all fees taken as needed from the asset.485       * 486       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.487       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send488       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.489       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be490       * an `AccountId32` value.491       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the492       * `dest` side.493       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay494       * fees.495       **/496      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]>;497      send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;498      /**499       * Teleport some assets from the local chain to some destination chain.500       * 501       * Fee payment on the destination side is made from the asset in the `assets` vector of502       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,503       * with all fees taken as needed from the asset.504       * 505       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.506       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send507       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.508       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be509       * an `AccountId32` value.510       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the511       * `dest` side. May not be empty.512       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay513       * fees.514       **/515      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]>;516      /**517       * Generic tx518       **/519      [key: string]: SubmittableExtrinsicFunction<ApiType>;520    };521    rmrkCore: {522      /**523       * Accept an NFT sent from another account to self or an owned NFT.524       * 525       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.526       * 527       * # Permissions:528       * - Token-owner-to-be529       * 530       * # Arguments:531       * - `origin`: sender of the transaction532       * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.533       * - `rmrk_nft_id`: ID of the NFT to be accepted.534       * - `new_owner`: Either the sender's account ID or a sender-owned NFT,535       * whichever the accepted NFT was sent to.536       **/537      acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;538      /**539       * Accept the addition of a newly created pending resource to an existing NFT.540       * 541       * This transaction is needed when a resource is created and assigned to an NFT542       * by a non-owner, i.e. the collection issuer, with one of the543       * [`add_...` transactions](Pallet::add_basic_resource).544       * 545       * # Permissions:546       * - Token owner547       * 548       * # Arguments:549       * - `origin`: sender of the transaction550       * - `rmrk_collection_id`: RMRK collection ID of the NFT.551       * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.552       * - `resource_id`: ID of the newly created pending resource.553       * accept the addition of a new resource to an existing NFT554       **/555      acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;556      /**557       * Accept the removal of a removal-pending resource from an NFT.558       * 559       * This transaction is needed when a non-owner, i.e. the collection issuer,560       * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.561       * 562       * # Permissions:563       * - Token owner564       * 565       * # Arguments:566       * - `origin`: sender of the transaction567       * - `rmrk_collection_id`: RMRK collection ID of the NFT.568       * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.569       * - `resource_id`: ID of the removal-pending resource.570       **/571      acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;572      /**573       * Create and set/propose a basic resource for an NFT.574       * 575       * A basic resource is the simplest, lacking a Base and anything that comes with it.576       * See RMRK docs for more information and examples.577       * 578       * # Permissions:579       * - Collection issuer - if not the token owner, adding the resource will warrant580       * the owner's [acceptance](Pallet::accept_resource).581       * 582       * # Arguments:583       * - `origin`: sender of the transaction584       * - `rmrk_collection_id`: RMRK collection ID of the NFT.585       * - `nft_id`: ID of the NFT to assign a resource to.586       * - `resource`: Data of the resource to be created.587       **/588      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]>;589      /**590       * Create and set/propose a composable resource for an NFT.591       * 592       * A composable resource links to a Base and has a subset of its Parts it is composed of.593       * See RMRK docs for more information and examples.594       * 595       * # Permissions:596       * - Collection issuer - if not the token owner, adding the resource will warrant597       * the owner's [acceptance](Pallet::accept_resource).598       * 599       * # Arguments:600       * - `origin`: sender of the transaction601       * - `rmrk_collection_id`: RMRK collection ID of the NFT.602       * - `nft_id`: ID of the NFT to assign a resource to.603       * - `resource`: Data of the resource to be created.604       **/605      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]>;606      /**607       * Create and set/propose a slot resource for an NFT.608       * 609       * A slot resource links to a Base and a slot ID in it which it can fit into.610       * See RMRK docs for more information and examples.611       * 612       * # Permissions:613       * - Collection issuer - if not the token owner, adding the resource will warrant614       * the owner's [acceptance](Pallet::accept_resource).615       * 616       * # Arguments:617       * - `origin`: sender of the transaction618       * - `rmrk_collection_id`: RMRK collection ID of the NFT.619       * - `nft_id`: ID of the NFT to assign a resource to.620       * - `resource`: Data of the resource to be created.621       **/622      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]>;623      /**624       * Burn an NFT, destroying it and its nested tokens up to the specified limit.625       * If the burning budget is exceeded, the transaction is reverted.626       * 627       * This is the way to burn a nested token as well.628       * 629       * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).630       * 631       * # Permissions:632       * * Token owner633       * 634       * # Arguments:635       * - `origin`: sender of the transaction636       * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.637       * - `nft_id`: ID of the NFT to be destroyed.638       * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction639       * is reverted if there are more tokens to burn in the nesting tree than this number.640       * This is primarily a mechanism of transaction weight control.641       **/642      burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;643      /**644       * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).645       * 646       * # Permissions:647       * * Collection issuer648       * 649       * # Arguments:650       * - `origin`: sender of the transaction651       * - `collection_id`: RMRK collection ID to change the issuer of.652       * - `new_issuer`: Collection's new issuer.653       **/654      changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;655      /**656       * Create a new collection of NFTs.657       * 658       * # Permissions:659       * * Anyone - will be assigned as the issuer of the collection.660       * 661       * # Arguments:662       * - `origin`: sender of the transaction663       * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.664       * - `max`: Optional maximum number of tokens.665       * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.666       * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.667       **/668      createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;669      /**670       * Destroy a collection.671       * 672       * Only empty collections can be destroyed. If it has any tokens, they must be burned first.673       * 674       * # Permissions:675       * * Collection issuer676       * 677       * # Arguments:678       * - `origin`: sender of the transaction679       * - `collection_id`: RMRK ID of the collection to destroy.680       **/681      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;682      /**683       * "Lock" the collection and prevent new token creation. Cannot be undone.684       * 685       * # Permissions:686       * * Collection issuer687       * 688       * # Arguments:689       * - `origin`: sender of the transaction690       * - `collection_id`: RMRK ID of the collection to lock.691       **/692      lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;693      /**694       * Mint an NFT in a specified collection.695       * 696       * # Permissions:697       * * Collection issuer698       * 699       * # Arguments:700       * - `origin`: sender of the transaction701       * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).702       * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.703       * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.704       * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.705       * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.706       * - `transferable`: Can this NFT be transferred? Cannot be changed.707       * - `resources`: Resource data to be added to the NFT immediately after minting.708       **/709      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>>]>;710      /**711       * Reject an NFT sent from another account to self or owned NFT.712       * The NFT in question will not be sent back and burnt instead.713       * 714       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.715       * 716       * # Permissions:717       * - Token-owner-to-be-not718       * 719       * # Arguments:720       * - `origin`: sender of the transaction721       * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.722       * - `rmrk_nft_id`: ID of the NFT to be rejected.723       **/724      rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;725      /**726       * Remove and erase a resource from an NFT.727       * 728       * If the sender does not own the NFT, then it will be pending confirmation,729       * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.730       * 731       * # Permissions732       * - Collection issuer733       * 734       * # Arguments735       * - `origin`: sender of the transaction736       * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.737       * - `nft_id`: ID of the NFT with a resource to be removed.738       * - `resource_id`: ID of the resource to be removed.739       **/740      removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;741      /**742       * Transfer an NFT from an account/NFT A to another account/NFT B.743       * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].744       * 745       * If the target owner is an NFT owned by another account, then the NFT will enter746       * the pending state and will have to be accepted by the other account.747       * 748       * # Permissions:749       * - Token owner750       * 751       * # Arguments:752       * - `origin`: sender of the transaction753       * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.754       * - `rmrk_nft_id`: ID of the NFT to be transferred.755       * - `new_owner`: New owner of the nft which can be either an account or a NFT.756       **/757      send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;758      /**759       * Set a different order of resource priorities for an NFT. Priorities can be used,760       * for example, for order of rendering.761       * 762       * Note that the priorities are not updated automatically, and are an empty vector763       * by default. There is no pre-set definition for the order to be particular,764       * it can be interpreted arbitrarily use-case by use-case.765       * 766       * # Permissions:767       * - Token owner768       * 769       * # Arguments:770       * - `origin`: sender of the transaction771       * - `rmrk_collection_id`: RMRK collection ID of the NFT.772       * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.773       * - `priorities`: Ordered vector of resource IDs.774       **/775      setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;776      /**777       * Add or edit a custom user property, a key-value pair, describing the metadata778       * of a token or a collection, on either one of these.779       * 780       * Note that in this proxy implementation many details regarding RMRK are stored781       * as scoped properties prefixed with "rmrk:", normally inaccessible782       * to external transactions and RPCs.783       * 784       * # Permissions:785       * - Collection issuer - in case of collection property786       * - Token owner - in case of NFT property787       * 788       * # Arguments:789       * - `origin`: sender of the transaction790       * - `rmrk_collection_id`: RMRK collection ID.791       * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.792       * - `key`: Key of the custom property to be referenced by.793       * - `value`: Value of the custom property to be stored.794       **/795      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]>;796      /**797       * Generic tx798       **/799      [key: string]: SubmittableExtrinsicFunction<ApiType>;800    };801    rmrkEquip: {802      /**803       * Create a new Base.804       * 805       * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)806       * 807       * # Permissions808       * - Anyone - will be assigned as the issuer of the Base.809       * 810       * # Arguments:811       * - `origin`: Caller, will be assigned as the issuer of the Base812       * - `base_type`: Arbitrary media type, e.g. "svg".813       * - `symbol`: Arbitrary client-chosen symbol.814       * - `parts`: Array of Fixed and Slot Parts composing the Base,815       * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).816       **/817      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>]>;818      /**819       * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.820       * 821       * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).822       * 823       * # Permissions:824       * - Base issuer825       * 826       * # Arguments:827       * - `origin`: sender of the transaction828       * - `base_id`: Base containing the Slot Part to be updated.829       * - `slot_id`: Slot Part whose Equippable List is being updated .830       * - `equippables`: List of equippables that will override the current Equippables list.831       **/832      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]>;833      /**834       * Add a Theme to a Base.835       * A Theme named "default" is required prior to adding other Themes.836       * 837       * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).838       * 839       * # Permissions:840       * - Base issuer841       * 842       * # Arguments:843       * - `origin`: sender of the transaction844       * - `base_id`: Base ID containing the Theme to be updated.845       * - `theme`: Theme to add to the Base.  A Theme has a name and properties, which are an846       * array of [key, value, inherit].847       * - `key`: Arbitrary BoundedString, defined by client.848       * - `value`: Arbitrary BoundedString, defined by client.849       * - `inherit`: Optional bool.850       **/851      themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;852      /**853       * Generic tx854       **/855      [key: string]: SubmittableExtrinsicFunction<ApiType>;856    };857    structure: {858      /**859       * Generic tx860       **/861      [key: string]: SubmittableExtrinsicFunction<ApiType>;862    };863    sudo: {864      /**865       * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo866       * key.867       * 868       * The dispatch origin for this call must be _Signed_.869       * 870       * # <weight>871       * - O(1).872       * - Limited storage reads.873       * - One DB change.874       * # </weight>875       **/876      setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;877      /**878       * Authenticates the sudo key and dispatches a function call with `Root` origin.879       * 880       * The dispatch origin for this call must be _Signed_.881       * 882       * # <weight>883       * - O(1).884       * - Limited storage reads.885       * - One DB write (event).886       * - Weight of derivative `call` execution + 10,000.887       * # </weight>888       **/889      sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;890      /**891       * Authenticates the sudo key and dispatches a function call with `Signed` origin from892       * a given account.893       * 894       * The dispatch origin for this call must be _Signed_.895       * 896       * # <weight>897       * - O(1).898       * - Limited storage reads.899       * - One DB write (event).900       * - Weight of derivative `call` execution + 10,000.901       * # </weight>902       **/903      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]>;904      /**905       * Authenticates the sudo key and dispatches a function call with `Root` origin.906       * This function does not check the weight of the call, and instead allows the907       * Sudo user to specify the weight of the call.908       * 909       * The dispatch origin for this call must be _Signed_.910       * 911       * # <weight>912       * - O(1).913       * - The weight of this call is defined by the caller.914       * # </weight>915       **/916      sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;917      /**918       * Generic tx919       **/920      [key: string]: SubmittableExtrinsicFunction<ApiType>;921    };922    system: {923      /**924       * Kill all storage items with a key that starts with the given prefix.925       * 926       * **NOTE:** We rely on the Root origin to provide us the number of subkeys under927       * the prefix we are removing to accurately calculate the weight of this function.928       **/929      killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;930      /**931       * Kill some items from storage.932       **/933      killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;934      /**935       * Make some on-chain remark.936       * 937       * # <weight>938       * - `O(1)`939       * # </weight>940       **/941      remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;942      /**943       * Make some on-chain remark and emit event.944       **/945      remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;946      /**947       * Set the new runtime code.948       * 949       * # <weight>950       * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`951       * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is952       * expensive).953       * - 1 storage write (codec `O(C)`).954       * - 1 digest item.955       * - 1 event.956       * The weight of this function is dependent on the runtime, but generally this is very957       * expensive. We will treat this as a full block.958       * # </weight>959       **/960      setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;961      /**962       * Set the new runtime code without doing any checks of the given `code`.963       * 964       * # <weight>965       * - `O(C)` where `C` length of `code`966       * - 1 storage write (codec `O(C)`).967       * - 1 digest item.968       * - 1 event.969       * The weight of this function is dependent on the runtime. We will treat this as a full970       * block. # </weight>971       **/972      setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;973      /**974       * Set the number of pages in the WebAssembly environment's heap.975       **/976      setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;977      /**978       * Set some items of storage.979       **/980      setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;981      /**982       * Generic tx983       **/984      [key: string]: SubmittableExtrinsicFunction<ApiType>;985    };986    testUtils: {987      batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;988      enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;989      incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;990      justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;991      setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;992      setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;993      /**994       * Generic tx995       **/996      [key: string]: SubmittableExtrinsicFunction<ApiType>;997    };998    timestamp: {999      /**1000       * Set the current time.1001       * 1002       * This call should be invoked exactly once per block. It will panic at the finalization1003       * phase, if this call hasn't been invoked by that time.1004       * 1005       * The timestamp should be greater than the previous one by the amount specified by1006       * `MinimumPeriod`.1007       * 1008       * The dispatch origin for this call must be `Inherent`.1009       * 1010       * # <weight>1011       * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1012       * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1013       * `on_finalize`)1014       * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1015       * # </weight>1016       **/1017      set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1018      /**1019       * Generic tx1020       **/1021      [key: string]: SubmittableExtrinsicFunction<ApiType>;1022    };1023    tokens: {1024      /**1025       * Exactly as `transfer`, except the origin must be root and the source1026       * account may be specified.1027       * 1028       * The dispatch origin for this call must be _Root_.1029       * 1030       * - `source`: The sender of the transfer.1031       * - `dest`: The recipient of the transfer.1032       * - `currency_id`: currency type.1033       * - `amount`: free balance amount to tranfer.1034       **/1035      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>]>;1036      /**1037       * Set the balances of a given account.1038       * 1039       * This will alter `FreeBalance` and `ReservedBalance` in storage. it1040       * will also decrease the total issuance of the system1041       * (`TotalIssuance`). If the new free or reserved balance is below the1042       * existential deposit, it will reap the `AccountInfo`.1043       * 1044       * The dispatch origin for this call is `root`.1045       **/1046      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>]>;1047      /**1048       * Transfer some liquid free balance to another account.1049       * 1050       * `transfer` will set the `FreeBalance` of the sender and receiver.1051       * It will decrease the total issuance of the system by the1052       * `TransferFee`. If the sender's account is below the existential1053       * deposit as a result of the transfer, the account will be reaped.1054       * 1055       * The dispatch origin for this call must be `Signed` by the1056       * transactor.1057       * 1058       * - `dest`: The recipient of the transfer.1059       * - `currency_id`: currency type.1060       * - `amount`: free balance amount to tranfer.1061       **/1062      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>]>;1063      /**1064       * Transfer all remaining balance to the given account.1065       * 1066       * NOTE: This function only attempts to transfer _transferable_1067       * balances. This means that any locked, reserved, or existential1068       * deposits (when `keep_alive` is `true`), will not be transferred by1069       * this function. To ensure that this function results in a killed1070       * account, you might need to prepare the account by removing any1071       * reference counters, storage deposits, etc...1072       * 1073       * The dispatch origin for this call must be `Signed` by the1074       * transactor.1075       * 1076       * - `dest`: The recipient of the transfer.1077       * - `currency_id`: currency type.1078       * - `keep_alive`: A boolean to determine if the `transfer_all`1079       * operation should send all of the funds the account has, causing1080       * the sender account to be killed (false), or transfer everything1081       * except at least the existential deposit, which will guarantee to1082       * keep the sender account alive (true).1083       **/1084      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]>;1085      /**1086       * Same as the [`transfer`] call, but with a check that the transfer1087       * will not kill the origin account.1088       * 1089       * 99% of the time you want [`transfer`] instead.1090       * 1091       * The dispatch origin for this call must be `Signed` by the1092       * transactor.1093       * 1094       * - `dest`: The recipient of the transfer.1095       * - `currency_id`: currency type.1096       * - `amount`: free balance amount to tranfer.1097       **/1098      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>]>;1099      /**1100       * Generic tx1101       **/1102      [key: string]: SubmittableExtrinsicFunction<ApiType>;1103    };1104    treasury: {1105      /**1106       * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1107       * and the original deposit will be returned.1108       * 1109       * May only be called from `T::ApproveOrigin`.1110       * 1111       * # <weight>1112       * - Complexity: O(1).1113       * - DbReads: `Proposals`, `Approvals`1114       * - DbWrite: `Approvals`1115       * # </weight>1116       **/1117      approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1118      /**1119       * Put forward a suggestion for spending. A deposit proportional to the value1120       * is reserved and slashed if the proposal is rejected. It is returned once the1121       * proposal is awarded.1122       * 1123       * # <weight>1124       * - Complexity: O(1)1125       * - DbReads: `ProposalCount`, `origin account`1126       * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1127       * # </weight>1128       **/1129      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]>;1130      /**1131       * Reject a proposed spend. The original deposit will be slashed.1132       * 1133       * May only be called from `T::RejectOrigin`.1134       * 1135       * # <weight>1136       * - Complexity: O(1)1137       * - DbReads: `Proposals`, `rejected proposer account`1138       * - DbWrites: `Proposals`, `rejected proposer account`1139       * # </weight>1140       **/1141      rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1142      /**1143       * Force a previously approved proposal to be removed from the approval queue.1144       * The original deposit will no longer be returned.1145       * 1146       * May only be called from `T::RejectOrigin`.1147       * - `proposal_id`: The index of a proposal1148       * 1149       * # <weight>1150       * - Complexity: O(A) where `A` is the number of approvals1151       * - Db reads and writes: `Approvals`1152       * # </weight>1153       * 1154       * Errors:1155       * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1156       * i.e., the proposal has not been approved. This could also mean the proposal does not1157       * exist altogether, thus there is no way it would have been approved in the first place.1158       **/1159      removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1160      /**1161       * Propose and approve a spend of treasury funds.1162       * 1163       * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1164       * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1165       * - `beneficiary`: The destination account for the transfer.1166       * 1167       * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1168       * beneficiary.1169       **/1170      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]>;1171      /**1172       * Generic tx1173       **/1174      [key: string]: SubmittableExtrinsicFunction<ApiType>;1175    };1176    unique: {1177      /**1178       * Add an admin to a collection.1179       * 1180       * NFT Collection can be controlled by multiple admin addresses1181       * (some which can also be servers, for example). Admins can issue1182       * and burn NFTs, as well as add and remove other admins,1183       * but cannot change NFT or Collection ownership.1184       * 1185       * # Permissions1186       * 1187       * * Collection owner1188       * * Collection admin1189       * 1190       * # Arguments1191       * 1192       * * `collection_id`: ID of the Collection to add an admin for.1193       * * `new_admin`: Address of new admin to add.1194       **/1195      addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1196      /**1197       * Add an address to allow list.1198       * 1199       * # Permissions1200       * 1201       * * Collection owner1202       * * Collection admin1203       * 1204       * # Arguments1205       * 1206       * * `collection_id`: ID of the modified collection.1207       * * `address`: ID of the address to be added to the allowlist.1208       **/1209      addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1210      /**1211       * Allow a non-permissioned address to transfer or burn an item.1212       * 1213       * # Permissions1214       * 1215       * * Collection owner1216       * * Collection admin1217       * * Current item owner1218       * 1219       * # Arguments1220       * 1221       * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1222       * * `collection_id`: ID of the collection the item belongs to.1223       * * `item_id`: ID of the item transactions on which are now approved.1224       * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1225       * Set to 0 to revoke the approval.1226       **/1227      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]>;1228      /**1229       * Destroy a token on behalf of the owner as a non-owner account.1230       * 1231       * See also: [`approve`][`Pallet::approve`].1232       * 1233       * After this method executes, one approval is removed from the total so that1234       * the approved address will not be able to transfer this item again from this owner.1235       * 1236       * # Permissions1237       * 1238       * * Collection owner1239       * * Collection admin1240       * * Current token owner1241       * * Address approved by current item owner1242       * 1243       * # Arguments1244       * 1245       * * `from`: The owner of the burning item.1246       * * `collection_id`: ID of the collection to which the item belongs.1247       * * `item_id`: ID of item to burn.1248       * * `value`: Number of pieces to burn.1249       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1250       * * Fungible Mode: The desired number of pieces to burn.1251       * * Re-Fungible Mode: The desired number of pieces to burn.1252       **/1253      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]>;1254      /**1255       * Destroy an item.1256       * 1257       * # Permissions1258       * 1259       * * Collection owner1260       * * Collection admin1261       * * Current item owner1262       * 1263       * # Arguments1264       * 1265       * * `collection_id`: ID of the collection to which the item belongs.1266       * * `item_id`: ID of item to burn.1267       * * `value`: Number of pieces of the item to destroy.1268       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1269       * * Fungible Mode: The desired number of pieces to burn.1270       * * Re-Fungible Mode: The desired number of pieces to burn.1271       **/1272      burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1273      /**1274       * Change the owner of the collection.1275       * 1276       * # Permissions1277       * 1278       * * Collection owner1279       * 1280       * # Arguments1281       * 1282       * * `collection_id`: ID of the modified collection.1283       * * `new_owner`: ID of the account that will become the owner.1284       **/1285      changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1286      /**1287       * Confirm own sponsorship of a collection, becoming the sponsor.1288       * 1289       * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1290       * Sponsor can pay the fees of a transaction instead of the sender,1291       * but only within specified limits.1292       * 1293       * # Permissions1294       * 1295       * * Sponsor-to-be1296       * 1297       * # Arguments1298       * 1299       * * `collection_id`: ID of the collection with the pending sponsor.1300       **/1301      confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1302      /**1303       * Create a collection of tokens.1304       * 1305       * Each Token may have multiple properties encoded as an array of bytes1306       * of certain length. The initial owner of the collection is set1307       * to the address that signed the transaction and can be changed later.1308       * 1309       * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1310       * 1311       * # Permissions1312       * 1313       * * Anyone - becomes the owner of the new collection.1314       * 1315       * # Arguments1316       * 1317       * * `collection_name`: Wide-character string with collection name1318       * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1319       * * `collection_description`: Wide-character string with collection description1320       * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1321       * * `token_prefix`: Byte string containing the token prefix to mark a collection1322       * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1323       * * `mode`: Type of items stored in the collection and type dependent data.1324       **/1325      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]>;1326      /**1327       * Create a collection with explicit parameters.1328       * 1329       * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1330       * 1331       * # Permissions1332       * 1333       * * Anyone - becomes the owner of the new collection.1334       * 1335       * # Arguments1336       * 1337       * * `data`: Explicit data of a collection used for its creation.1338       **/1339      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]>;1340      /**1341       * Mint an item within a collection.1342       * 1343       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1344       * 1345       * # Permissions1346       * 1347       * * Collection owner1348       * * Collection admin1349       * * Anyone if1350       * * Allow List is enabled, and1351       * * Address is added to allow list, and1352       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1353       * 1354       * # Arguments1355       * 1356       * * `collection_id`: ID of the collection to which an item would belong.1357       * * `owner`: Address of the initial owner of the item.1358       * * `data`: Token data describing the item to store on chain.1359       **/1360      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]>;1361      /**1362       * Create multiple items within a collection.1363       * 1364       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1365       * 1366       * # Permissions1367       * 1368       * * Collection owner1369       * * Collection admin1370       * * Anyone if1371       * * Allow List is enabled, and1372       * * Address is added to the allow list, and1373       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1374       * 1375       * # Arguments1376       * 1377       * * `collection_id`: ID of the collection to which the tokens would belong.1378       * * `owner`: Address of the initial owner of the tokens.1379       * * `items_data`: Vector of data describing each item to be created.1380       **/1381      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>]>;1382      /**1383       * Create multiple items within a collection with explicitly specified initial parameters.1384       * 1385       * # Permissions1386       * 1387       * * Collection owner1388       * * Collection admin1389       * * Anyone if1390       * * Allow List is enabled, and1391       * * Address is added to allow list, and1392       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1393       * 1394       * # Arguments1395       * 1396       * * `collection_id`: ID of the collection to which the tokens would belong.1397       * * `data`: Explicit item creation data.1398       **/1399      createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1400      /**1401       * Delete specified collection properties.1402       * 1403       * # Permissions1404       * 1405       * * Collection Owner1406       * * Collection Admin1407       * 1408       * # Arguments1409       * 1410       * * `collection_id`: ID of the modified collection.1411       * * `property_keys`: Vector of keys of the properties to be deleted.1412       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1413       **/1414      deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1415      /**1416       * Delete specified token properties. Currently properties only work with NFTs.1417       * 1418       * # Permissions1419       * 1420       * * Depends on collection's token property permissions and specified property mutability:1421       * * Collection owner1422       * * Collection admin1423       * * Token owner1424       * 1425       * # Arguments1426       * 1427       * * `collection_id`: ID of the collection to which the token belongs.1428       * * `token_id`: ID of the modified token.1429       * * `property_keys`: Vector of keys of the properties to be deleted.1430       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1431       **/1432      deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1433      /**1434       * Destroy a collection if no tokens exist within.1435       * 1436       * # Permissions1437       * 1438       * * Collection owner1439       * 1440       * # Arguments1441       * 1442       * * `collection_id`: Collection to destroy.1443       **/1444      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1445      /**1446       * Repairs a collection if the data was somehow corrupted.1447       * 1448       * # Arguments1449       * 1450       * * `collection_id`: ID of the collection to repair.1451       **/1452      forceRepairCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1453      /**1454       * Repairs a token if the data was somehow corrupted.1455       * 1456       * # Arguments1457       * 1458       * * `collection_id`: ID of the collection the item belongs to.1459       * * `item_id`: ID of the item.1460       **/1461      forceRepairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1462      /**1463       * Remove admin of a collection.1464       * 1465       * An admin address can remove itself. List of admins may become empty,1466       * in which case only Collection Owner will be able to add an Admin.1467       * 1468       * # Permissions1469       * 1470       * * Collection owner1471       * * Collection admin1472       * 1473       * # Arguments1474       * 1475       * * `collection_id`: ID of the collection to remove the admin for.1476       * * `account_id`: Address of the admin to remove.1477       **/1478      removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1479      /**1480       * Remove a collection's a sponsor, making everyone pay for their own transactions.1481       * 1482       * # Permissions1483       * 1484       * * Collection owner1485       * 1486       * # Arguments1487       * 1488       * * `collection_id`: ID of the collection with the sponsor to remove.1489       **/1490      removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1491      /**1492       * Remove an address from allow list.1493       * 1494       * # Permissions1495       * 1496       * * Collection owner1497       * * Collection admin1498       * 1499       * # Arguments1500       * 1501       * * `collection_id`: ID of the modified collection.1502       * * `address`: ID of the address to be removed from the allowlist.1503       **/1504      removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1505      /**1506       * Re-partition a refungible token, while owning all of its parts/pieces.1507       * 1508       * # Permissions1509       * 1510       * * Token owner (must own every part)1511       * 1512       * # Arguments1513       * 1514       * * `collection_id`: ID of the collection the RFT belongs to.1515       * * `token_id`: ID of the RFT.1516       * * `amount`: New number of parts/pieces into which the token shall be partitioned.1517       **/1518      repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1519      /**1520       * Sets or unsets the approval of a given operator.1521       * 1522       * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1523       * 1524       * # Arguments1525       * 1526       * * `owner`: Token owner1527       * * `operator`: Operator1528       * * `approve`: Should operator status be granted or revoked?1529       **/1530      setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1531      /**1532       * Set specific limits of a collection. Empty, or None fields mean chain default.1533       * 1534       * # Permissions1535       * 1536       * * Collection owner1537       * * Collection admin1538       * 1539       * # Arguments1540       * 1541       * * `collection_id`: ID of the modified collection.1542       * * `new_limit`: New limits of the collection. Fields that are not set (None)1543       * will not overwrite the old ones.1544       **/1545      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]>;1546      /**1547       * Set specific permissions of a collection. Empty, or None fields mean chain default.1548       * 1549       * # Permissions1550       * 1551       * * Collection owner1552       * * Collection admin1553       * 1554       * # Arguments1555       * 1556       * * `collection_id`: ID of the modified collection.1557       * * `new_permission`: New permissions of the collection. Fields that are not set (None)1558       * will not overwrite the old ones.1559       **/1560      setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1561      /**1562       * Add or change collection properties.1563       * 1564       * # Permissions1565       * 1566       * * Collection owner1567       * * Collection admin1568       * 1569       * # Arguments1570       * 1571       * * `collection_id`: ID of the modified collection.1572       * * `properties`: Vector of key-value pairs stored as the collection's metadata.1573       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1574       **/1575      setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1576      /**1577       * Set (invite) a new collection sponsor.1578       * 1579       * If successful, confirmation from the sponsor-to-be will be pending.1580       * 1581       * # Permissions1582       * 1583       * * Collection owner1584       * * Collection admin1585       * 1586       * # Arguments1587       * 1588       * * `collection_id`: ID of the modified collection.1589       * * `new_sponsor`: ID of the account of the sponsor-to-be.1590       **/1591      setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1592      /**1593       * Add or change token properties according to collection's permissions.1594       * Currently properties only work with NFTs.1595       * 1596       * # Permissions1597       * 1598       * * Depends on collection's token property permissions and specified property mutability:1599       * * Collection owner1600       * * Collection admin1601       * * Token owner1602       * 1603       * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1604       * 1605       * # Arguments1606       * 1607       * * `collection_id: ID of the collection to which the token belongs.1608       * * `token_id`: ID of the modified token.1609       * * `properties`: Vector of key-value pairs stored as the token's metadata.1610       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1611       **/1612      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>]>;1613      /**1614       * Add or change token property permissions of a collection.1615       * 1616       * Without a permission for a particular key, a property with that key1617       * cannot be created in a token.1618       * 1619       * # Permissions1620       * 1621       * * Collection owner1622       * * Collection admin1623       * 1624       * # Arguments1625       * 1626       * * `collection_id`: ID of the modified collection.1627       * * `property_permissions`: Vector of permissions for property keys.1628       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1629       **/1630      setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1631      /**1632       * Completely allow or disallow transfers for a particular collection.1633       * 1634       * # Permissions1635       * 1636       * * Collection owner1637       * 1638       * # Arguments1639       * 1640       * * `collection_id`: ID of the collection.1641       * * `value`: New value of the flag, are transfers allowed?1642       **/1643      setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1644      /**1645       * Change ownership of the token.1646       * 1647       * # Permissions1648       * 1649       * * Collection owner1650       * * Collection admin1651       * * Current token owner1652       * 1653       * # Arguments1654       * 1655       * * `recipient`: Address of token recipient.1656       * * `collection_id`: ID of the collection the item belongs to.1657       * * `item_id`: ID of the item.1658       * * Non-Fungible Mode: Required.1659       * * Fungible Mode: Ignored.1660       * * Re-Fungible Mode: Required.1661       * 1662       * * `value`: Amount to transfer.1663       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1664       * * Fungible Mode: The desired number of pieces to transfer.1665       * * Re-Fungible Mode: The desired number of pieces to transfer.1666       **/1667      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]>;1668      /**1669       * Change ownership of an item on behalf of the owner as a non-owner account.1670       * 1671       * See the [`approve`][`Pallet::approve`] method for additional information.1672       * 1673       * After this method executes, one approval is removed from the total so that1674       * the approved address will not be able to transfer this item again from this owner.1675       * 1676       * # Permissions1677       * 1678       * * Collection owner1679       * * Collection admin1680       * * Current item owner1681       * * Address approved by current item owner1682       * 1683       * # Arguments1684       * 1685       * * `from`: Address that currently owns the token.1686       * * `recipient`: Address of the new token-owner-to-be.1687       * * `collection_id`: ID of the collection the item.1688       * * `item_id`: ID of the item to be transferred.1689       * * `value`: Amount to transfer.1690       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1691       * * Fungible Mode: The desired number of pieces to transfer.1692       * * Re-Fungible Mode: The desired number of pieces to transfer.1693       **/1694      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]>;1695      /**1696       * Generic tx1697       **/1698      [key: string]: SubmittableExtrinsicFunction<ApiType>;1699    };1700    vesting: {1701      claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1702      claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1703      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>]>;1704      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]>;1705      /**1706       * Generic tx1707       **/1708      [key: string]: SubmittableExtrinsicFunction<ApiType>;1709    };1710    xcmpQueue: {1711      /**1712       * Resumes all XCM executions for the XCMP queue.1713       * 1714       * Note that this function doesn't change the status of the in/out bound channels.1715       * 1716       * - `origin`: Must pass `ControllerOrigin`.1717       **/1718      resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1719      /**1720       * Services a single overweight XCM.1721       * 1722       * - `origin`: Must pass `ExecuteOverweightOrigin`.1723       * - `index`: The index of the overweight XCM to service1724       * - `weight_limit`: The amount of weight that XCM execution may take.1725       * 1726       * Errors:1727       * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1728       * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1729       * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1730       * 1731       * Events:1732       * - `OverweightServiced`: On success.1733       **/1734      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1735      /**1736       * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1737       * 1738       * - `origin`: Must pass `ControllerOrigin`.1739       **/1740      suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1741      /**1742       * Overwrites the number of pages of messages which must be in the queue after which we drop any further1743       * messages from the channel.1744       * 1745       * - `origin`: Must pass `Root`.1746       * - `new`: Desired value for `QueueConfigData.drop_threshold`1747       **/1748      updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1749      /**1750       * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1751       * message sending may recommence after it has been suspended.1752       * 1753       * - `origin`: Must pass `Root`.1754       * - `new`: Desired value for `QueueConfigData.resume_threshold`1755       **/1756      updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1757      /**1758       * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1759       * suspend their sending.1760       * 1761       * - `origin`: Must pass `Root`.1762       * - `new`: Desired value for `QueueConfigData.suspend_value`1763       **/1764      updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1765      /**1766       * Overwrites the amount of remaining weight under which we stop processing messages.1767       * 1768       * - `origin`: Must pass `Root`.1769       * - `new`: Desired value for `QueueConfigData.threshold_weight`1770       **/1771      updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1772      /**1773       * Overwrites the speed to which the available weight approaches the maximum weight.1774       * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1775       * 1776       * - `origin`: Must pass `Root`.1777       * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1778       **/1779      updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1780      /**1781       * Overwrite the maximum amount of weight any individual message may consume.1782       * Messages above this weight go into the overweight queue and may only be serviced explicitly.1783       * 1784       * - `origin`: Must pass `Root`.1785       * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1786       **/1787      updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1788      /**1789       * Generic tx1790       **/1791      [key: string]: SubmittableExtrinsicFunction<ApiType>;1792    };1793    xTokens: {1794      /**1795       * Transfer native currencies.1796       * 1797       * `dest_weight_limit` is the weight for XCM execution on the dest1798       * chain, and it would be charged from the transferred assets. If set1799       * below requirements, the execution may fail and assets wouldn't be1800       * received.1801       * 1802       * It's a no-op if any error on local XCM execution or message sending.1803       * Note sending assets out per se doesn't guarantee they would be1804       * received. Receiving depends on if the XCM message could be delivered1805       * by the network, and if the receiving chain would handle1806       * messages correctly.1807       **/1808      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]>;1809      /**1810       * Transfer `MultiAsset`.1811       * 1812       * `dest_weight_limit` is the weight for XCM execution on the dest1813       * chain, and it would be charged from the transferred assets. If set1814       * below requirements, the execution may fail and assets wouldn't be1815       * received.1816       * 1817       * It's a no-op if any error on local XCM execution or message sending.1818       * Note sending assets out per se doesn't guarantee they would be1819       * received. Receiving depends on if the XCM message could be delivered1820       * by the network, and if the receiving chain would handle1821       * messages correctly.1822       **/1823      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]>;1824      /**1825       * Transfer several `MultiAsset` specifying the item to be used as fee1826       * 1827       * `dest_weight_limit` is the weight for XCM execution on the dest1828       * chain, and it would be charged from the transferred assets. If set1829       * below requirements, the execution may fail and assets wouldn't be1830       * received.1831       * 1832       * `fee_item` is index of the MultiAssets that we want to use for1833       * payment1834       * 1835       * It's a no-op if any error on local XCM execution or message sending.1836       * Note sending assets out per se doesn't guarantee they would be1837       * received. Receiving depends on if the XCM message could be delivered1838       * by the network, and if the receiving chain would handle1839       * messages correctly.1840       **/1841      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]>;1842      /**1843       * Transfer `MultiAsset` specifying the fee and amount as separate.1844       * 1845       * `dest_weight_limit` is the weight for XCM execution on the dest1846       * chain, and it would be charged from the transferred assets. If set1847       * below requirements, the execution may fail and assets wouldn't be1848       * received.1849       * 1850       * `fee` is the multiasset to be spent to pay for execution in1851       * destination chain. Both fee and amount will be subtracted form the1852       * callers balance For now we only accept fee and asset having the same1853       * `MultiLocation` id.1854       * 1855       * If `fee` is not high enough to cover for the execution costs in the1856       * destination chain, then the assets will be trapped in the1857       * destination chain1858       * 1859       * It's a no-op if any error on local XCM execution or message sending.1860       * Note sending assets out per se doesn't guarantee they would be1861       * received. Receiving depends on if the XCM message could be delivered1862       * by the network, and if the receiving chain would handle1863       * messages correctly.1864       **/1865      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]>;1866      /**1867       * Transfer several currencies specifying the item to be used as fee1868       * 1869       * `dest_weight_limit` is the weight for XCM execution on the dest1870       * chain, and it would be charged from the transferred assets. If set1871       * below requirements, the execution may fail and assets wouldn't be1872       * received.1873       * 1874       * `fee_item` is index of the currencies tuple that we want to use for1875       * payment1876       * 1877       * It's a no-op if any error on local XCM execution or message sending.1878       * Note sending assets out per se doesn't guarantee they would be1879       * received. Receiving depends on if the XCM message could be delivered1880       * by the network, and if the receiving chain would handle1881       * messages correctly.1882       **/1883      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]>;1884      /**1885       * Transfer native currencies specifying the fee and amount as1886       * separate.1887       * 1888       * `dest_weight_limit` is the weight for XCM execution on the dest1889       * chain, and it would be charged from the transferred assets. If set1890       * below requirements, the execution may fail and assets wouldn't be1891       * received.1892       * 1893       * `fee` is the amount to be spent to pay for execution in destination1894       * chain. Both fee and amount will be subtracted form the callers1895       * balance.1896       * 1897       * If `fee` is not high enough to cover for the execution costs in the1898       * destination chain, then the assets will be trapped in the1899       * destination chain1900       * 1901       * It's a no-op if any error on local XCM execution or message sending.1902       * Note sending assets out per se doesn't guarantee they would be1903       * received. Receiving depends on if the XCM message could be delivered1904       * by the network, and if the receiving chain would handle1905       * messages correctly.1906       **/1907      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]>;1908      /**1909       * Generic tx1910       **/1911      [key: string]: SubmittableExtrinsicFunction<ApiType>;1912    };1913  } // AugmentedSubmittables1914} // declare module