git.delta.rocks / unique-network / refs/commits / 895a035cdc96

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 { Data } from '@polkadot/types';10import type { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';11import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';12import type { AccountId32, Call, H160, H256, MultiAddress, Permill } from '@polkadot/types/interfaces/runtime';13import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumLog, EthereumTransactionTransactionV2, OpalRuntimeRuntimeCommonSessionKeys, OrmlVestingVestingSchedule, PalletConfigurationAppPromotionConfiguration, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletIdentityBitFlags, PalletIdentityIdentityInfo, PalletIdentityJudgement, PalletIdentityRegistration, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, SpRuntimeHeader, SpWeightsWeightV2Weight, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';1415export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;16export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;17export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;1819declare module '@polkadot/api-base/types/submittable' {20  interface AugmentedSubmittables<ApiType extends ApiTypes> {21    appPromotion: {22      /**23       * Recalculates interest for the specified number of stakers.24       * If all stakers are not recalculated, the next call of the extrinsic25       * will continue the recalculation, from those stakers for whom this26       * was not perform in last call.27       * 28       * # Permissions29       * 30       * * Pallet admin31       * 32       * # Arguments33       * 34       * * `stakers_number`: the number of stakers for which recalculation will be performed35       **/36      payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;37      /**38       * Sets an address as the the admin.39       * 40       * # Permissions41       * 42       * * Sudo43       * 44       * # Arguments45       * 46       * * `admin`: account of the new admin.47       **/48      setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;49      /**50       * Sets the pallet to be the sponsor for the collection.51       * 52       * # Permissions53       * 54       * * Pallet admin55       * 56       * # Arguments57       * 58       * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`59       **/60      sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;61      /**62       * Sets the pallet to be the sponsor for the contract.63       * 64       * # Permissions65       * 66       * * Pallet admin67       * 68       * # Arguments69       * 70       * * `contract_id`: the contract address that will be sponsored by `pallet_id`71       **/72      sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;73      /**74       * Stakes the amount of native tokens.75       * Sets `amount` to the locked state.76       * The maximum number of stakes for a staker is 10.77       * 78       * # Arguments79       * 80       * * `amount`: in native tokens.81       **/82      stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;83      /**84       * Removes the pallet as the sponsor for the collection.85       * Returns [`NoPermission`][`Error::NoPermission`]86       * if the pallet wasn't the sponsor.87       * 88       * # Permissions89       * 90       * * Pallet admin91       * 92       * # Arguments93       * 94       * * `collection_id`: ID of the collection that is sponsored by `pallet_id`95       **/96      stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;97      /**98       * Removes the pallet as the sponsor for the contract.99       * Returns [`NoPermission`][`Error::NoPermission`]100       * if the pallet wasn't the sponsor.101       * 102       * # Permissions103       * 104       * * Pallet admin105       * 106       * # Arguments107       * 108       * * `contract_id`: the contract address that is sponsored by `pallet_id`109       **/110      stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;111      /**112       * Unstakes all stakes.113       * Moves the sum of all stakes to the `reserved` state.114       * After the end of `PendingInterval` this sum becomes completely115       * free for further use.116       **/117      unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;118      /**119       * Generic tx120       **/121      [key: string]: SubmittableExtrinsicFunction<ApiType>;122    };123    authorship: {124      /**125       * Provide a set of uncles.126       **/127      setUncles: AugmentedSubmittable<(newUncles: Vec<SpRuntimeHeader> | (SpRuntimeHeader | { parentHash?: any; number?: any; stateRoot?: any; extrinsicsRoot?: any; digest?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<SpRuntimeHeader>]>;128      /**129       * Generic tx130       **/131      [key: string]: SubmittableExtrinsicFunction<ApiType>;132    };133    balances: {134      /**135       * Exactly as `transfer`, except the origin must be root and the source account may be136       * specified.137       * # <weight>138       * - Same as transfer, but additional read and write because the source account is not139       * assumed to be in the overlay.140       * # </weight>141       **/142      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>]>;143      /**144       * Unreserve some balance from a user by force.145       * 146       * Can only be called by ROOT.147       **/148      forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;149      /**150       * Set the balances of a given account.151       * 152       * This will alter `FreeBalance` and `ReservedBalance` in storage. it will153       * also alter the total issuance of the system (`TotalIssuance`) appropriately.154       * If the new free or reserved balance is below the existential deposit,155       * it will reset the account nonce (`frame_system::AccountNonce`).156       * 157       * The dispatch origin for this call is `root`.158       **/159      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>]>;160      /**161       * Transfer some liquid free balance to another account.162       * 163       * `transfer` will set the `FreeBalance` of the sender and receiver.164       * If the sender's account is below the existential deposit as a result165       * of the transfer, the account will be reaped.166       * 167       * The dispatch origin for this call must be `Signed` by the transactor.168       * 169       * # <weight>170       * - Dependent on arguments but not critical, given proper implementations for input config171       * types. See related functions below.172       * - It contains a limited number of reads and writes internally and no complex173       * computation.174       * 175       * Related functions:176       * 177       * - `ensure_can_withdraw` is always called internally but has a bounded complexity.178       * - Transferring balances to accounts that did not exist before will cause179       * `T::OnNewAccount::on_new_account` to be called.180       * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.181       * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check182       * that the transfer will not kill the origin account.183       * ---------------------------------184       * - Origin account is already in memory, so no DB operations for them.185       * # </weight>186       **/187      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>]>;188      /**189       * Transfer the entire transferable balance from the caller account.190       * 191       * NOTE: This function only attempts to transfer _transferable_ balances. This means that192       * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be193       * transferred by this function. To ensure that this function results in a killed account,194       * you might need to prepare the account by removing any reference counters, storage195       * deposits, etc...196       * 197       * The dispatch origin of this call must be Signed.198       * 199       * - `dest`: The recipient of the transfer.200       * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all201       * of the funds the account has, causing the sender account to be killed (false), or202       * transfer everything except at least the existential deposit, which will guarantee to203       * keep the sender account alive (true). # <weight>204       * - O(1). Just like transfer, but reading the user's transferable balance first.205       * #</weight>206       **/207      transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;208      /**209       * Same as the [`transfer`] call, but with a check that the transfer will not kill the210       * origin account.211       * 212       * 99% of the time you want [`transfer`] instead.213       * 214       * [`transfer`]: struct.Pallet.html#method.transfer215       **/216      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>]>;217      /**218       * Generic tx219       **/220      [key: string]: SubmittableExtrinsicFunction<ApiType>;221    };222    charging: {223      /**224       * Generic tx225       **/226      [key: string]: SubmittableExtrinsicFunction<ApiType>;227    };228    collatorSelection: {229      /**230       * Add a collator to the list of invulnerable (fixed) collators.231       **/232      addInvulnerable: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;233      /**234       * Force deregister `origin` as a collator candidate as a governing authority, and revoke its license.235       * Note that the collator can only leave on session change.236       * The `LicenseBond` will be unreserved and returned immediately.237       * 238       * This call is, of course, not applicable to `Invulnerable` collators.239       **/240      forceReleaseLicense: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;241      /**242       * Purchase a license on block collation for this account.243       * It does not make it a collator candidate, use `onboard` afterward. The account must244       * (a) already have registered session keys and (b) be able to reserve the `LicenseBond`.245       * 246       * This call is not available to `Invulnerable` collators.247       **/248      getLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;249      /**250       * Deregister `origin` as a collator candidate. Note that the collator can only leave on251       * session change. The license to `onboard` later at any other time will remain.252       **/253      offboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;254      /**255       * Register this account as a candidate for collators for next sessions.256       * The account must already hold a license, and cannot offboard immediately during a session.257       * 258       * This call is not available to `Invulnerable` collators.259       **/260      onboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;261      /**262       * Forfeit `origin`'s own license. The `LicenseBond` will be unreserved immediately.263       * 264       * This call is not available to `Invulnerable` collators.265       **/266      releaseLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;267      /**268       * Remove a collator from the list of invulnerable (fixed) collators.269       **/270      removeInvulnerable: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;271      /**272       * Generic tx273       **/274      [key: string]: SubmittableExtrinsicFunction<ApiType>;275    };276    configuration: {277      setAppPromotionConfigurationOverride: AugmentedSubmittable<(configuration: PalletConfigurationAppPromotionConfiguration | { recalculationInterval?: any; pendingInterval?: any; intervalIncome?: any; maxStakersPerCalculation?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletConfigurationAppPromotionConfiguration]>;278      setCollatorSelectionDesiredCollators: AugmentedSubmittable<(max: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;279      setCollatorSelectionKickThreshold: AugmentedSubmittable<(threshold: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;280      setCollatorSelectionLicenseBond: AugmentedSubmittable<(amount: Option<u128> | null | Uint8Array | u128 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u128>]>;281      setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;282      setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;283      setXcmAllowedLocations: AugmentedSubmittable<(locations: Option<Vec<XcmV1MultiLocation>> | null | Uint8Array | Vec<XcmV1MultiLocation> | (XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<Vec<XcmV1MultiLocation>>]>;284      /**285       * Generic tx286       **/287      [key: string]: SubmittableExtrinsicFunction<ApiType>;288    };289    cumulusXcm: {290      /**291       * Generic tx292       **/293      [key: string]: SubmittableExtrinsicFunction<ApiType>;294    };295    dmpQueue: {296      /**297       * Service a single overweight message.298       * 299       * - `origin`: Must pass `ExecuteOverweightOrigin`.300       * - `index`: The index of the overweight message to service.301       * - `weight_limit`: The amount of weight that message execution may take.302       * 303       * Errors:304       * - `Unknown`: Message of `index` is unknown.305       * - `OverLimit`: Message execution may use greater than `weight_limit`.306       * 307       * Events:308       * - `OverweightServiced`: On success.309       **/310      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;311      /**312       * Generic tx313       **/314      [key: string]: SubmittableExtrinsicFunction<ApiType>;315    };316    ethereum: {317      /**318       * Transact an Ethereum transaction.319       **/320      transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;321      /**322       * Generic tx323       **/324      [key: string]: SubmittableExtrinsicFunction<ApiType>;325    };326    evm: {327      /**328       * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.329       **/330      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>]>>]>;331      /**332       * Issue an EVM create operation. This is similar to a contract creation transaction in333       * Ethereum.334       **/335      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>]>>]>;336      /**337       * Issue an EVM create2 operation.338       **/339      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>]>>]>;340      /**341       * Withdraw balance from EVM into currency/balances pallet.342       **/343      withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;344      /**345       * Generic tx346       **/347      [key: string]: SubmittableExtrinsicFunction<ApiType>;348    };349    evmMigration: {350      /**351       * Start contract migration, inserts contract stub at target address,352       * and marks account as pending, allowing to insert storage353       **/354      begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;355      /**356       * Finish contract migration, allows it to be called.357       * It is not possible to alter contract storage via [`Self::set_data`]358       * after this call.359       **/360      finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;361      /**362       * Create ethereum events attached to the fake transaction363       **/364      insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;365      /**366       * Create substrate events367       **/368      insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;369      /**370       * Insert items into contract storage, this method can be called371       * multiple times372       **/373      setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;374      /**375       * Generic tx376       **/377      [key: string]: SubmittableExtrinsicFunction<ApiType>;378    };379    foreignAssets: {380      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]>;381      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]>;382      /**383       * Generic tx384       **/385      [key: string]: SubmittableExtrinsicFunction<ApiType>;386    };387    identity: {388      /**389       * Add a registrar to the system.390       * 391       * The dispatch origin for this call must be `T::RegistrarOrigin`.392       * 393       * - `account`: the account of the registrar.394       * 395       * Emits `RegistrarAdded` if successful.396       * 397       * # <weight>398       * - `O(R)` where `R` registrar-count (governance-bounded and code-bounded).399       * - One storage mutation (codec `O(R)`).400       * - One event.401       * # </weight>402       **/403      addRegistrar: AugmentedSubmittable<(account: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;404      /**405       * Add the given account to the sender's subs.406       * 407       * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated408       * to the sender.409       * 410       * The dispatch origin for this call must be _Signed_ and the sender must have a registered411       * sub identity of `sub`.412       **/413      addSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, data: Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Data]>;414      /**415       * Cancel a previous request.416       * 417       * Payment: A previously reserved deposit is returned on success.418       * 419       * The dispatch origin for this call must be _Signed_ and the sender must have a420       * registered identity.421       * 422       * - `reg_index`: The index of the registrar whose judgement is no longer requested.423       * 424       * Emits `JudgementUnrequested` if successful.425       * 426       * # <weight>427       * - `O(R + X)`.428       * - One balance-reserve operation.429       * - One storage mutation `O(R + X)`.430       * - One event431       * # </weight>432       **/433      cancelRequest: AugmentedSubmittable<(regIndex: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;434      /**435       * Clear an account's identity info and all sub-accounts and return all deposits.436       * 437       * Payment: All reserved balances on the account are returned.438       * 439       * The dispatch origin for this call must be _Signed_ and the sender must have a registered440       * identity.441       * 442       * Emits `IdentityCleared` if successful.443       * 444       * # <weight>445       * - `O(R + S + X)`446       * - where `R` registrar-count (governance-bounded).447       * - where `S` subs-count (hard- and deposit-bounded).448       * - where `X` additional-field-count (deposit-bounded and code-bounded).449       * - One balance-unreserve operation.450       * - `2` storage reads and `S + 2` storage deletions.451       * - One event.452       * # </weight>453       **/454      clearIdentity: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;455      /**456       * Set identities to be associated with the provided accounts as force origin.457       * 458       * This is not meant to operate in tandem with the identity pallet as is,459       * and be instead used to keep identities made and verified externally,460       * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.461       **/462      forceInsertIdentities: AugmentedSubmittable<(identities: Vec<ITuple<[AccountId32, PalletIdentityRegistration]>> | ([AccountId32 | string | Uint8Array, PalletIdentityRegistration | { judgements?: any; deposit?: any; info?: any } | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[AccountId32, PalletIdentityRegistration]>>]>;463      /**464       * Remove identities associated with the provided accounts as force origin.465       * 466       * This is not meant to operate in tandem with the identity pallet as is,467       * and be instead used to keep identities made and verified externally,468       * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.469       **/470      forceRemoveIdentities: AugmentedSubmittable<(identities: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;471      /**472       * Remove an account's identity and sub-account information and slash the deposits.473       * 474       * Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled by475       * `Slash`. Verification request deposits are not returned; they should be cancelled476       * manually using `cancel_request`.477       * 478       * The dispatch origin for this call must match `T::ForceOrigin`.479       * 480       * - `target`: the account whose identity the judgement is upon. This must be an account481       * with a registered identity.482       * 483       * Emits `IdentityKilled` if successful.484       * 485       * # <weight>486       * - `O(R + S + X)`.487       * - One balance-reserve operation.488       * - `S + 2` storage mutations.489       * - One event.490       * # </weight>491       **/492      killIdentity: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;493      /**494       * Provide a judgement for an account's identity.495       * 496       * The dispatch origin for this call must be _Signed_ and the sender must be the account497       * of the registrar whose index is `reg_index`.498       * 499       * - `reg_index`: the index of the registrar whose judgement is being made.500       * - `target`: the account whose identity the judgement is upon. This must be an account501       * with a registered identity.502       * - `judgement`: the judgement of the registrar of index `reg_index` about `target`.503       * - `identity`: The hash of the [`IdentityInfo`] for that the judgement is provided.504       * 505       * Emits `JudgementGiven` if successful.506       * 507       * # <weight>508       * - `O(R + X)`.509       * - One balance-transfer operation.510       * - Up to one account-lookup operation.511       * - Storage: 1 read `O(R)`, 1 mutate `O(R + X)`.512       * - One event.513       * # </weight>514       **/515      provideJudgement: AugmentedSubmittable<(regIndex: Compact<u32> | AnyNumber | Uint8Array, target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, judgement: PalletIdentityJudgement | { Unknown: any } | { FeePaid: any } | { Reasonable: any } | { KnownGood: any } | { OutOfDate: any } | { LowQuality: any } | { Erroneous: any } | string | Uint8Array, identity: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, MultiAddress, PalletIdentityJudgement, H256]>;516      /**517       * Remove the sender as a sub-account.518       * 519       * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated520       * to the sender (*not* the original depositor).521       * 522       * The dispatch origin for this call must be _Signed_ and the sender must have a registered523       * super-identity.524       * 525       * NOTE: This should not normally be used, but is provided in the case that the non-526       * controller of an account is maliciously registered as a sub-account.527       **/528      quitSub: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;529      /**530       * Remove the given account from the sender's subs.531       * 532       * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated533       * to the sender.534       * 535       * The dispatch origin for this call must be _Signed_ and the sender must have a registered536       * sub identity of `sub`.537       **/538      removeSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;539      /**540       * Alter the associated name of the given sub-account.541       * 542       * The dispatch origin for this call must be _Signed_ and the sender must have a registered543       * sub identity of `sub`.544       **/545      renameSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, data: Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Data]>;546      /**547       * Request a judgement from a registrar.548       * 549       * Payment: At most `max_fee` will be reserved for payment to the registrar if judgement550       * given.551       * 552       * The dispatch origin for this call must be _Signed_ and the sender must have a553       * registered identity.554       * 555       * - `reg_index`: The index of the registrar whose judgement is requested.556       * - `max_fee`: The maximum fee that may be paid. This should just be auto-populated as:557       * 558       * ```nocompile559       * Self::registrars().get(reg_index).unwrap().fee560       * ```561       * 562       * Emits `JudgementRequested` if successful.563       * 564       * # <weight>565       * - `O(R + X)`.566       * - One balance-reserve operation.567       * - Storage: 1 read `O(R)`, 1 mutate `O(X + R)`.568       * - One event.569       * # </weight>570       **/571      requestJudgement: AugmentedSubmittable<(regIndex: Compact<u32> | AnyNumber | Uint8Array, maxFee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;572      /**573       * Change the account associated with a registrar.574       * 575       * The dispatch origin for this call must be _Signed_ and the sender must be the account576       * of the registrar whose index is `index`.577       * 578       * - `index`: the index of the registrar whose fee is to be set.579       * - `new`: the new account ID.580       * 581       * # <weight>582       * - `O(R)`.583       * - One storage mutation `O(R)`.584       * - Benchmark: 8.823 + R * 0.32 µs (min squares analysis)585       * # </weight>586       **/587      setAccountId: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, MultiAddress]>;588      /**589       * Set the fee required for a judgement to be requested from a registrar.590       * 591       * The dispatch origin for this call must be _Signed_ and the sender must be the account592       * of the registrar whose index is `index`.593       * 594       * - `index`: the index of the registrar whose fee is to be set.595       * - `fee`: the new fee.596       * 597       * # <weight>598       * - `O(R)`.599       * - One storage mutation `O(R)`.600       * - Benchmark: 7.315 + R * 0.329 µs (min squares analysis)601       * # </weight>602       **/603      setFee: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;604      /**605       * Set the field information for a registrar.606       * 607       * The dispatch origin for this call must be _Signed_ and the sender must be the account608       * of the registrar whose index is `index`.609       * 610       * - `index`: the index of the registrar whose fee is to be set.611       * - `fields`: the fields that the registrar concerns themselves with.612       * 613       * # <weight>614       * - `O(R)`.615       * - One storage mutation `O(R)`.616       * - Benchmark: 7.464 + R * 0.325 µs (min squares analysis)617       * # </weight>618       **/619      setFields: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fields: PalletIdentityBitFlags) => SubmittableExtrinsic<ApiType>, [Compact<u32>, PalletIdentityBitFlags]>;620      /**621       * Set an account's identity information and reserve the appropriate deposit.622       * 623       * If the account already has identity information, the deposit is taken as part payment624       * for the new deposit.625       * 626       * The dispatch origin for this call must be _Signed_.627       * 628       * - `info`: The identity information.629       * 630       * Emits `IdentitySet` if successful.631       * 632       * # <weight>633       * - `O(X + X' + R)`634       * - where `X` additional-field-count (deposit-bounded and code-bounded)635       * - where `R` judgements-count (registrar-count-bounded)636       * - One balance reserve operation.637       * - One storage mutation (codec-read `O(X' + R)`, codec-write `O(X + R)`).638       * - One event.639       * # </weight>640       **/641      setIdentity: AugmentedSubmittable<(info: PalletIdentityIdentityInfo | { additional?: any; display?: any; legal?: any; web?: any; riot?: any; email?: any; pgpFingerprint?: any; image?: any; twitter?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletIdentityIdentityInfo]>;642      /**643       * Set the sub-accounts of the sender.644       * 645       * Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned646       * and an amount `SubAccountDeposit` will be reserved for each item in `subs`.647       * 648       * The dispatch origin for this call must be _Signed_ and the sender must have a registered649       * identity.650       * 651       * - `subs`: The identity's (new) sub-accounts.652       * 653       * # <weight>654       * - `O(P + S)`655       * - where `P` old-subs-count (hard- and deposit-bounded).656       * - where `S` subs-count (hard- and deposit-bounded).657       * - At most one balance operations.658       * - DB:659       * - `P + S` storage mutations (codec complexity `O(1)`)660       * - One storage read (codec complexity `O(P)`).661       * - One storage write (codec complexity `O(S)`).662       * - One storage-exists (`IdentityOf::contains_key`).663       * # </weight>664       **/665      setSubs: AugmentedSubmittable<(subs: Vec<ITuple<[AccountId32, Data]>> | ([AccountId32 | string | Uint8Array, Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[AccountId32, Data]>>]>;666      /**667       * Generic tx668       **/669      [key: string]: SubmittableExtrinsicFunction<ApiType>;670    };671    inflation: {672      /**673       * This method sets the inflation start date. Can be only called once.674       * Inflation start block can be backdated and will catch up. The method will create Treasury675       * account if it does not exist and perform the first inflation deposit.676       * 677       * # Permissions678       * 679       * * Root680       * 681       * # Arguments682       * 683       * * inflation_start_relay_block: The relay chain block at which inflation should start684       **/685      startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;686      /**687       * Generic tx688       **/689      [key: string]: SubmittableExtrinsicFunction<ApiType>;690    };691    maintenance: {692      disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;693      enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;694      /**695       * Generic tx696       **/697      [key: string]: SubmittableExtrinsicFunction<ApiType>;698    };699    parachainSystem: {700      authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;701      enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;702      /**703       * Set the current validation data.704       * 705       * This should be invoked exactly once per block. It will panic at the finalization706       * phase if the call was not invoked.707       * 708       * The dispatch origin for this call must be `Inherent`709       * 710       * As a side effect, this function upgrades the current validation function711       * if the appropriate time has come.712       **/713      setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;714      sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;715      /**716       * Generic tx717       **/718      [key: string]: SubmittableExtrinsicFunction<ApiType>;719    };720    polkadotXcm: {721      /**722       * Execute an XCM message from a local, signed, origin.723       * 724       * An event is deposited indicating whether `msg` could be executed completely or only725       * partially.726       * 727       * No more than `max_weight` will be used in its attempted execution. If this is less than the728       * maximum amount of weight that the message could take to be executed, then no execution729       * attempt will be made.730       * 731       * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully732       * to completion; only that *some* of it was executed.733       **/734      execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;735      /**736       * Set a safe XCM version (the version that XCM should be encoded with if the most recent737       * version a destination can accept is unknown).738       * 739       * - `origin`: Must be Root.740       * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.741       **/742      forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;743      /**744       * Ask a location to notify us regarding their XCM version and any changes to it.745       * 746       * - `origin`: Must be Root.747       * - `location`: The location to which we should subscribe for XCM version notifications.748       **/749      forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;750      /**751       * Require that a particular destination should no longer notify us regarding any XCM752       * version changes.753       * 754       * - `origin`: Must be Root.755       * - `location`: The location to which we are currently subscribed for XCM version756       * notifications which we no longer desire.757       **/758      forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;759      /**760       * Extoll that a particular destination can be communicated with through a particular761       * version of XCM.762       * 763       * - `origin`: Must be Root.764       * - `location`: The destination that is being described.765       * - `xcm_version`: The latest version of XCM that `location` supports.766       **/767      forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;768      /**769       * Transfer some assets from the local chain to the sovereign account of a destination770       * chain and forward a notification XCM.771       * 772       * Fee payment on the destination side is made from the asset in the `assets` vector of773       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight774       * is needed than `weight_limit`, then the operation will fail and the assets send may be775       * at risk.776       * 777       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.778       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send779       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.780       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be781       * an `AccountId32` value.782       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the783       * `dest` side.784       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay785       * fees.786       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.787       **/788      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]>;789      /**790       * Teleport some assets from the local chain to some destination chain.791       * 792       * Fee payment on the destination side is made from the asset in the `assets` vector of793       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight794       * is needed than `weight_limit`, then the operation will fail and the assets send may be795       * at risk.796       * 797       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.798       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send799       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.800       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be801       * an `AccountId32` value.802       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the803       * `dest` side. May not be empty.804       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay805       * fees.806       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.807       **/808      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]>;809      /**810       * Transfer some assets from the local chain to the sovereign account of a destination811       * chain and forward a notification XCM.812       * 813       * Fee payment on the destination side is made from the asset in the `assets` vector of814       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,815       * with all fees taken as needed from the asset.816       * 817       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.818       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send819       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.820       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be821       * an `AccountId32` value.822       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the823       * `dest` side.824       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay825       * fees.826       **/827      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]>;828      send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;829      /**830       * Teleport some assets from the local chain to some destination chain.831       * 832       * Fee payment on the destination side is made from the asset in the `assets` vector of833       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,834       * with all fees taken as needed from the asset.835       * 836       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.837       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send838       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.839       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be840       * an `AccountId32` value.841       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the842       * `dest` side. May not be empty.843       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay844       * fees.845       **/846      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]>;847      /**848       * Generic tx849       **/850      [key: string]: SubmittableExtrinsicFunction<ApiType>;851    };852    rmrkCore: {853      /**854       * Accept an NFT sent from another account to self or an owned NFT.855       * 856       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.857       * 858       * # Permissions:859       * - Token-owner-to-be860       * 861       * # Arguments:862       * - `origin`: sender of the transaction863       * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.864       * - `rmrk_nft_id`: ID of the NFT to be accepted.865       * - `new_owner`: Either the sender's account ID or a sender-owned NFT,866       * whichever the accepted NFT was sent to.867       **/868      acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;869      /**870       * Accept the addition of a newly created pending resource to an existing NFT.871       * 872       * This transaction is needed when a resource is created and assigned to an NFT873       * by a non-owner, i.e. the collection issuer, with one of the874       * [`add_...` transactions](Pallet::add_basic_resource).875       * 876       * # Permissions:877       * - Token owner878       * 879       * # Arguments:880       * - `origin`: sender of the transaction881       * - `rmrk_collection_id`: RMRK collection ID of the NFT.882       * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.883       * - `resource_id`: ID of the newly created pending resource.884       * accept the addition of a new resource to an existing NFT885       **/886      acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;887      /**888       * Accept the removal of a removal-pending resource from an NFT.889       * 890       * This transaction is needed when a non-owner, i.e. the collection issuer,891       * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.892       * 893       * # Permissions:894       * - Token owner895       * 896       * # Arguments:897       * - `origin`: sender of the transaction898       * - `rmrk_collection_id`: RMRK collection ID of the NFT.899       * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.900       * - `resource_id`: ID of the removal-pending resource.901       **/902      acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;903      /**904       * Create and set/propose a basic resource for an NFT.905       * 906       * A basic resource is the simplest, lacking a Base and anything that comes with it.907       * See RMRK docs for more information and examples.908       * 909       * # Permissions:910       * - Collection issuer - if not the token owner, adding the resource will warrant911       * the owner's [acceptance](Pallet::accept_resource).912       * 913       * # Arguments:914       * - `origin`: sender of the transaction915       * - `rmrk_collection_id`: RMRK collection ID of the NFT.916       * - `nft_id`: ID of the NFT to assign a resource to.917       * - `resource`: Data of the resource to be created.918       **/919      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]>;920      /**921       * Create and set/propose a composable resource for an NFT.922       * 923       * A composable resource links to a Base and has a subset of its Parts it is composed of.924       * See RMRK docs for more information and examples.925       * 926       * # Permissions:927       * - Collection issuer - if not the token owner, adding the resource will warrant928       * the owner's [acceptance](Pallet::accept_resource).929       * 930       * # Arguments:931       * - `origin`: sender of the transaction932       * - `rmrk_collection_id`: RMRK collection ID of the NFT.933       * - `nft_id`: ID of the NFT to assign a resource to.934       * - `resource`: Data of the resource to be created.935       **/936      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]>;937      /**938       * Create and set/propose a slot resource for an NFT.939       * 940       * A slot resource links to a Base and a slot ID in it which it can fit into.941       * See RMRK docs for more information and examples.942       * 943       * # Permissions:944       * - Collection issuer - if not the token owner, adding the resource will warrant945       * the owner's [acceptance](Pallet::accept_resource).946       * 947       * # Arguments:948       * - `origin`: sender of the transaction949       * - `rmrk_collection_id`: RMRK collection ID of the NFT.950       * - `nft_id`: ID of the NFT to assign a resource to.951       * - `resource`: Data of the resource to be created.952       **/953      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]>;954      /**955       * Burn an NFT, destroying it and its nested tokens up to the specified limit.956       * If the burning budget is exceeded, the transaction is reverted.957       * 958       * This is the way to burn a nested token as well.959       * 960       * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).961       * 962       * # Permissions:963       * * Token owner964       * 965       * # Arguments:966       * - `origin`: sender of the transaction967       * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.968       * - `nft_id`: ID of the NFT to be destroyed.969       * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction970       * is reverted if there are more tokens to burn in the nesting tree than this number.971       * This is primarily a mechanism of transaction weight control.972       **/973      burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;974      /**975       * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).976       * 977       * # Permissions:978       * * Collection issuer979       * 980       * # Arguments:981       * - `origin`: sender of the transaction982       * - `collection_id`: RMRK collection ID to change the issuer of.983       * - `new_issuer`: Collection's new issuer.984       **/985      changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;986      /**987       * Create a new collection of NFTs.988       * 989       * # Permissions:990       * * Anyone - will be assigned as the issuer of the collection.991       * 992       * # Arguments:993       * - `origin`: sender of the transaction994       * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.995       * - `max`: Optional maximum number of tokens.996       * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.997       * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.998       **/999      createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;1000      /**1001       * Destroy a collection.1002       * 1003       * Only empty collections can be destroyed. If it has any tokens, they must be burned first.1004       * 1005       * # Permissions:1006       * * Collection issuer1007       * 1008       * # Arguments:1009       * - `origin`: sender of the transaction1010       * - `collection_id`: RMRK ID of the collection to destroy.1011       **/1012      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1013      /**1014       * "Lock" the collection and prevent new token creation. Cannot be undone.1015       * 1016       * # Permissions:1017       * * Collection issuer1018       * 1019       * # Arguments:1020       * - `origin`: sender of the transaction1021       * - `collection_id`: RMRK ID of the collection to lock.1022       **/1023      lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1024      /**1025       * Mint an NFT in a specified collection.1026       * 1027       * # Permissions:1028       * * Collection issuer1029       * 1030       * # Arguments:1031       * - `origin`: sender of the transaction1032       * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).1033       * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.1034       * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.1035       * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.1036       * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.1037       * - `transferable`: Can this NFT be transferred? Cannot be changed.1038       * - `resources`: Resource data to be added to the NFT immediately after minting.1039       **/1040      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>>]>;1041      /**1042       * Reject an NFT sent from another account to self or owned NFT.1043       * The NFT in question will not be sent back and burnt instead.1044       * 1045       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.1046       * 1047       * # Permissions:1048       * - Token-owner-to-be-not1049       * 1050       * # Arguments:1051       * - `origin`: sender of the transaction1052       * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.1053       * - `rmrk_nft_id`: ID of the NFT to be rejected.1054       **/1055      rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1056      /**1057       * Remove and erase a resource from an NFT.1058       * 1059       * If the sender does not own the NFT, then it will be pending confirmation,1060       * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.1061       * 1062       * # Permissions1063       * - Collection issuer1064       * 1065       * # Arguments1066       * - `origin`: sender of the transaction1067       * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.1068       * - `nft_id`: ID of the NFT with a resource to be removed.1069       * - `resource_id`: ID of the resource to be removed.1070       **/1071      removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;1072      /**1073       * Transfer an NFT from an account/NFT A to another account/NFT B.1074       * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].1075       * 1076       * If the target owner is an NFT owned by another account, then the NFT will enter1077       * the pending state and will have to be accepted by the other account.1078       * 1079       * # Permissions:1080       * - Token owner1081       * 1082       * # Arguments:1083       * - `origin`: sender of the transaction1084       * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.1085       * - `rmrk_nft_id`: ID of the NFT to be transferred.1086       * - `new_owner`: New owner of the nft which can be either an account or a NFT.1087       **/1088      send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;1089      /**1090       * Set a different order of resource priorities for an NFT. Priorities can be used,1091       * for example, for order of rendering.1092       * 1093       * Note that the priorities are not updated automatically, and are an empty vector1094       * by default. There is no pre-set definition for the order to be particular,1095       * it can be interpreted arbitrarily use-case by use-case.1096       * 1097       * # Permissions:1098       * - Token owner1099       * 1100       * # Arguments:1101       * - `origin`: sender of the transaction1102       * - `rmrk_collection_id`: RMRK collection ID of the NFT.1103       * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.1104       * - `priorities`: Ordered vector of resource IDs.1105       **/1106      setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;1107      /**1108       * Add or edit a custom user property, a key-value pair, describing the metadata1109       * of a token or a collection, on either one of these.1110       * 1111       * Note that in this proxy implementation many details regarding RMRK are stored1112       * as scoped properties prefixed with "rmrk:", normally inaccessible1113       * to external transactions and RPCs.1114       * 1115       * # Permissions:1116       * - Collection issuer - in case of collection property1117       * - Token owner - in case of NFT property1118       * 1119       * # Arguments:1120       * - `origin`: sender of the transaction1121       * - `rmrk_collection_id`: RMRK collection ID.1122       * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.1123       * - `key`: Key of the custom property to be referenced by.1124       * - `value`: Value of the custom property to be stored.1125       **/1126      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]>;1127      /**1128       * Generic tx1129       **/1130      [key: string]: SubmittableExtrinsicFunction<ApiType>;1131    };1132    rmrkEquip: {1133      /**1134       * Create a new Base.1135       * 1136       * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)1137       * 1138       * # Permissions1139       * - Anyone - will be assigned as the issuer of the Base.1140       * 1141       * # Arguments:1142       * - `origin`: Caller, will be assigned as the issuer of the Base1143       * - `base_type`: Arbitrary media type, e.g. "svg".1144       * - `symbol`: Arbitrary client-chosen symbol.1145       * - `parts`: Array of Fixed and Slot Parts composing the Base,1146       * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).1147       **/1148      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>]>;1149      /**1150       * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.1151       * 1152       * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).1153       * 1154       * # Permissions:1155       * - Base issuer1156       * 1157       * # Arguments:1158       * - `origin`: sender of the transaction1159       * - `base_id`: Base containing the Slot Part to be updated.1160       * - `slot_id`: Slot Part whose Equippable List is being updated .1161       * - `equippables`: List of equippables that will override the current Equippables list.1162       **/1163      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]>;1164      /**1165       * Add a Theme to a Base.1166       * A Theme named "default" is required prior to adding other Themes.1167       * 1168       * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).1169       * 1170       * # Permissions:1171       * - Base issuer1172       * 1173       * # Arguments:1174       * - `origin`: sender of the transaction1175       * - `base_id`: Base ID containing the Theme to be updated.1176       * - `theme`: Theme to add to the Base.  A Theme has a name and properties, which are an1177       * array of [key, value, inherit].1178       * - `key`: Arbitrary BoundedString, defined by client.1179       * - `value`: Arbitrary BoundedString, defined by client.1180       * - `inherit`: Optional bool.1181       **/1182      themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;1183      /**1184       * Generic tx1185       **/1186      [key: string]: SubmittableExtrinsicFunction<ApiType>;1187    };1188    session: {1189      /**1190       * Removes any session key(s) of the function caller.1191       * 1192       * This doesn't take effect until the next session.1193       * 1194       * The dispatch origin of this function must be Signed and the account must be either be1195       * convertible to a validator ID using the chain's typical addressing system (this usually1196       * means being a controller account) or directly convertible into a validator ID (which1197       * usually means being a stash account).1198       * 1199       * # <weight>1200       * - Complexity: `O(1)` in number of key types. Actual cost depends on the number of length1201       * of `T::Keys::key_ids()` which is fixed.1202       * - DbReads: `T::ValidatorIdOf`, `NextKeys`, `origin account`1203       * - DbWrites: `NextKeys`, `origin account`1204       * - DbWrites per key id: `KeyOwner`1205       * # </weight>1206       **/1207      purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1208      /**1209       * Sets the session key(s) of the function caller to `keys`.1210       * Allows an account to set its session key prior to becoming a validator.1211       * This doesn't take effect until the next session.1212       * 1213       * The dispatch origin of this function must be signed.1214       * 1215       * # <weight>1216       * - Complexity: `O(1)`. Actual cost depends on the number of length of1217       * `T::Keys::key_ids()` which is fixed.1218       * - DbReads: `origin account`, `T::ValidatorIdOf`, `NextKeys`1219       * - DbWrites: `origin account`, `NextKeys`1220       * - DbReads per key id: `KeyOwner`1221       * - DbWrites per key id: `KeyOwner`1222       * # </weight>1223       **/1224      setKeys: AugmentedSubmittable<(keys: OpalRuntimeRuntimeCommonSessionKeys | { aura?: any } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [OpalRuntimeRuntimeCommonSessionKeys, Bytes]>;1225      /**1226       * Generic tx1227       **/1228      [key: string]: SubmittableExtrinsicFunction<ApiType>;1229    };1230    structure: {1231      /**1232       * Generic tx1233       **/1234      [key: string]: SubmittableExtrinsicFunction<ApiType>;1235    };1236    sudo: {1237      /**1238       * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo1239       * key.1240       * 1241       * The dispatch origin for this call must be _Signed_.1242       * 1243       * # <weight>1244       * - O(1).1245       * - Limited storage reads.1246       * - One DB change.1247       * # </weight>1248       **/1249      setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1250      /**1251       * Authenticates the sudo key and dispatches a function call with `Root` origin.1252       * 1253       * The dispatch origin for this call must be _Signed_.1254       * 1255       * # <weight>1256       * - O(1).1257       * - Limited storage reads.1258       * - One DB write (event).1259       * - Weight of derivative `call` execution + 10,000.1260       * # </weight>1261       **/1262      sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;1263      /**1264       * Authenticates the sudo key and dispatches a function call with `Signed` origin from1265       * a given account.1266       * 1267       * The dispatch origin for this call must be _Signed_.1268       * 1269       * # <weight>1270       * - O(1).1271       * - Limited storage reads.1272       * - One DB write (event).1273       * - Weight of derivative `call` execution + 10,000.1274       * # </weight>1275       **/1276      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]>;1277      /**1278       * Authenticates the sudo key and dispatches a function call with `Root` origin.1279       * This function does not check the weight of the call, and instead allows the1280       * Sudo user to specify the weight of the call.1281       * 1282       * The dispatch origin for this call must be _Signed_.1283       * 1284       * # <weight>1285       * - O(1).1286       * - The weight of this call is defined by the caller.1287       * # </weight>1288       **/1289      sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;1290      /**1291       * Generic tx1292       **/1293      [key: string]: SubmittableExtrinsicFunction<ApiType>;1294    };1295    system: {1296      /**1297       * Kill all storage items with a key that starts with the given prefix.1298       * 1299       * **NOTE:** We rely on the Root origin to provide us the number of subkeys under1300       * the prefix we are removing to accurately calculate the weight of this function.1301       **/1302      killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;1303      /**1304       * Kill some items from storage.1305       **/1306      killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;1307      /**1308       * Make some on-chain remark.1309       * 1310       * # <weight>1311       * - `O(1)`1312       * # </weight>1313       **/1314      remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1315      /**1316       * Make some on-chain remark and emit event.1317       **/1318      remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1319      /**1320       * Set the new runtime code.1321       * 1322       * # <weight>1323       * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`1324       * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is1325       * expensive).1326       * - 1 storage write (codec `O(C)`).1327       * - 1 digest item.1328       * - 1 event.1329       * The weight of this function is dependent on the runtime, but generally this is very1330       * expensive. We will treat this as a full block.1331       * # </weight>1332       **/1333      setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1334      /**1335       * Set the new runtime code without doing any checks of the given `code`.1336       * 1337       * # <weight>1338       * - `O(C)` where `C` length of `code`1339       * - 1 storage write (codec `O(C)`).1340       * - 1 digest item.1341       * - 1 event.1342       * The weight of this function is dependent on the runtime. We will treat this as a full1343       * block. # </weight>1344       **/1345      setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1346      /**1347       * Set the number of pages in the WebAssembly environment's heap.1348       **/1349      setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1350      /**1351       * Set some items of storage.1352       **/1353      setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;1354      /**1355       * Generic tx1356       **/1357      [key: string]: SubmittableExtrinsicFunction<ApiType>;1358    };1359    testUtils: {1360      batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;1361      enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1362      incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1363      justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1364      setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1365      setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1366      /**1367       * Generic tx1368       **/1369      [key: string]: SubmittableExtrinsicFunction<ApiType>;1370    };1371    timestamp: {1372      /**1373       * Set the current time.1374       * 1375       * This call should be invoked exactly once per block. It will panic at the finalization1376       * phase, if this call hasn't been invoked by that time.1377       * 1378       * The timestamp should be greater than the previous one by the amount specified by1379       * `MinimumPeriod`.1380       * 1381       * The dispatch origin for this call must be `Inherent`.1382       * 1383       * # <weight>1384       * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1385       * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1386       * `on_finalize`)1387       * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1388       * # </weight>1389       **/1390      set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1391      /**1392       * Generic tx1393       **/1394      [key: string]: SubmittableExtrinsicFunction<ApiType>;1395    };1396    tokens: {1397      /**1398       * Exactly as `transfer`, except the origin must be root and the source1399       * account may be specified.1400       * 1401       * The dispatch origin for this call must be _Root_.1402       * 1403       * - `source`: The sender of the transfer.1404       * - `dest`: The recipient of the transfer.1405       * - `currency_id`: currency type.1406       * - `amount`: free balance amount to tranfer.1407       **/1408      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>]>;1409      /**1410       * Set the balances of a given account.1411       * 1412       * This will alter `FreeBalance` and `ReservedBalance` in storage. it1413       * will also decrease the total issuance of the system1414       * (`TotalIssuance`). If the new free or reserved balance is below the1415       * existential deposit, it will reap the `AccountInfo`.1416       * 1417       * The dispatch origin for this call is `root`.1418       **/1419      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>]>;1420      /**1421       * Transfer some liquid free balance to another account.1422       * 1423       * `transfer` will set the `FreeBalance` of the sender and receiver.1424       * It will decrease the total issuance of the system by the1425       * `TransferFee`. If the sender's account is below the existential1426       * deposit as a result of the transfer, the account will be reaped.1427       * 1428       * The dispatch origin for this call must be `Signed` by the1429       * transactor.1430       * 1431       * - `dest`: The recipient of the transfer.1432       * - `currency_id`: currency type.1433       * - `amount`: free balance amount to tranfer.1434       **/1435      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>]>;1436      /**1437       * Transfer all remaining balance to the given account.1438       * 1439       * NOTE: This function only attempts to transfer _transferable_1440       * balances. This means that any locked, reserved, or existential1441       * deposits (when `keep_alive` is `true`), will not be transferred by1442       * this function. To ensure that this function results in a killed1443       * account, you might need to prepare the account by removing any1444       * reference counters, storage deposits, etc...1445       * 1446       * The dispatch origin for this call must be `Signed` by the1447       * transactor.1448       * 1449       * - `dest`: The recipient of the transfer.1450       * - `currency_id`: currency type.1451       * - `keep_alive`: A boolean to determine if the `transfer_all`1452       * operation should send all of the funds the account has, causing1453       * the sender account to be killed (false), or transfer everything1454       * except at least the existential deposit, which will guarantee to1455       * keep the sender account alive (true).1456       **/1457      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]>;1458      /**1459       * Same as the [`transfer`] call, but with a check that the transfer1460       * will not kill the origin account.1461       * 1462       * 99% of the time you want [`transfer`] instead.1463       * 1464       * The dispatch origin for this call must be `Signed` by the1465       * transactor.1466       * 1467       * - `dest`: The recipient of the transfer.1468       * - `currency_id`: currency type.1469       * - `amount`: free balance amount to tranfer.1470       **/1471      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>]>;1472      /**1473       * Generic tx1474       **/1475      [key: string]: SubmittableExtrinsicFunction<ApiType>;1476    };1477    treasury: {1478      /**1479       * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1480       * and the original deposit will be returned.1481       * 1482       * May only be called from `T::ApproveOrigin`.1483       * 1484       * # <weight>1485       * - Complexity: O(1).1486       * - DbReads: `Proposals`, `Approvals`1487       * - DbWrite: `Approvals`1488       * # </weight>1489       **/1490      approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1491      /**1492       * Put forward a suggestion for spending. A deposit proportional to the value1493       * is reserved and slashed if the proposal is rejected. It is returned once the1494       * proposal is awarded.1495       * 1496       * # <weight>1497       * - Complexity: O(1)1498       * - DbReads: `ProposalCount`, `origin account`1499       * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1500       * # </weight>1501       **/1502      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]>;1503      /**1504       * Reject a proposed spend. The original deposit will be slashed.1505       * 1506       * May only be called from `T::RejectOrigin`.1507       * 1508       * # <weight>1509       * - Complexity: O(1)1510       * - DbReads: `Proposals`, `rejected proposer account`1511       * - DbWrites: `Proposals`, `rejected proposer account`1512       * # </weight>1513       **/1514      rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1515      /**1516       * Force a previously approved proposal to be removed from the approval queue.1517       * The original deposit will no longer be returned.1518       * 1519       * May only be called from `T::RejectOrigin`.1520       * - `proposal_id`: The index of a proposal1521       * 1522       * # <weight>1523       * - Complexity: O(A) where `A` is the number of approvals1524       * - Db reads and writes: `Approvals`1525       * # </weight>1526       * 1527       * Errors:1528       * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1529       * i.e., the proposal has not been approved. This could also mean the proposal does not1530       * exist altogether, thus there is no way it would have been approved in the first place.1531       **/1532      removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1533      /**1534       * Propose and approve a spend of treasury funds.1535       * 1536       * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1537       * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1538       * - `beneficiary`: The destination account for the transfer.1539       * 1540       * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1541       * beneficiary.1542       **/1543      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]>;1544      /**1545       * Generic tx1546       **/1547      [key: string]: SubmittableExtrinsicFunction<ApiType>;1548    };1549    unique: {1550      /**1551       * Add an admin to a collection.1552       * 1553       * NFT Collection can be controlled by multiple admin addresses1554       * (some which can also be servers, for example). Admins can issue1555       * and burn NFTs, as well as add and remove other admins,1556       * but cannot change NFT or Collection ownership.1557       * 1558       * # Permissions1559       * 1560       * * Collection owner1561       * * Collection admin1562       * 1563       * # Arguments1564       * 1565       * * `collection_id`: ID of the Collection to add an admin for.1566       * * `new_admin`: Address of new admin to add.1567       **/1568      addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1569      /**1570       * Add an address to allow list.1571       * 1572       * # Permissions1573       * 1574       * * Collection owner1575       * * Collection admin1576       * 1577       * # Arguments1578       * 1579       * * `collection_id`: ID of the modified collection.1580       * * `address`: ID of the address to be added to the allowlist.1581       **/1582      addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1583      /**1584       * Allow a non-permissioned address to transfer or burn an item.1585       * 1586       * # Permissions1587       * 1588       * * Collection owner1589       * * Collection admin1590       * * Current item owner1591       * 1592       * # Arguments1593       * 1594       * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1595       * * `collection_id`: ID of the collection the item belongs to.1596       * * `item_id`: ID of the item transactions on which are now approved.1597       * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1598       * Set to 0 to revoke the approval.1599       **/1600      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]>;1601      /**1602       * Destroy a token on behalf of the owner as a non-owner account.1603       * 1604       * See also: [`approve`][`Pallet::approve`].1605       * 1606       * After this method executes, one approval is removed from the total so that1607       * the approved address will not be able to transfer this item again from this owner.1608       * 1609       * # Permissions1610       * 1611       * * Collection owner1612       * * Collection admin1613       * * Current token owner1614       * * Address approved by current item owner1615       * 1616       * # Arguments1617       * 1618       * * `from`: The owner of the burning item.1619       * * `collection_id`: ID of the collection to which the item belongs.1620       * * `item_id`: ID of item to burn.1621       * * `value`: Number of pieces to burn.1622       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1623       * * Fungible Mode: The desired number of pieces to burn.1624       * * Re-Fungible Mode: The desired number of pieces to burn.1625       **/1626      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]>;1627      /**1628       * Destroy an item.1629       * 1630       * # Permissions1631       * 1632       * * Collection owner1633       * * Collection admin1634       * * Current item owner1635       * 1636       * # Arguments1637       * 1638       * * `collection_id`: ID of the collection to which the item belongs.1639       * * `item_id`: ID of item to burn.1640       * * `value`: Number of pieces of the item to destroy.1641       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1642       * * Fungible Mode: The desired number of pieces to burn.1643       * * Re-Fungible Mode: The desired number of pieces to burn.1644       **/1645      burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1646      /**1647       * Change the owner of the collection.1648       * 1649       * # Permissions1650       * 1651       * * Collection owner1652       * 1653       * # Arguments1654       * 1655       * * `collection_id`: ID of the modified collection.1656       * * `new_owner`: ID of the account that will become the owner.1657       **/1658      changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1659      /**1660       * Confirm own sponsorship of a collection, becoming the sponsor.1661       * 1662       * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1663       * Sponsor can pay the fees of a transaction instead of the sender,1664       * but only within specified limits.1665       * 1666       * # Permissions1667       * 1668       * * Sponsor-to-be1669       * 1670       * # Arguments1671       * 1672       * * `collection_id`: ID of the collection with the pending sponsor.1673       **/1674      confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1675      /**1676       * Create a collection of tokens.1677       * 1678       * Each Token may have multiple properties encoded as an array of bytes1679       * of certain length. The initial owner of the collection is set1680       * to the address that signed the transaction and can be changed later.1681       * 1682       * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1683       * 1684       * # Permissions1685       * 1686       * * Anyone - becomes the owner of the new collection.1687       * 1688       * # Arguments1689       * 1690       * * `collection_name`: Wide-character string with collection name1691       * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1692       * * `collection_description`: Wide-character string with collection description1693       * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1694       * * `token_prefix`: Byte string containing the token prefix to mark a collection1695       * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1696       * * `mode`: Type of items stored in the collection and type dependent data.1697       **/1698      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]>;1699      /**1700       * Create a collection with explicit parameters.1701       * 1702       * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1703       * 1704       * # Permissions1705       * 1706       * * Anyone - becomes the owner of the new collection.1707       * 1708       * # Arguments1709       * 1710       * * `data`: Explicit data of a collection used for its creation.1711       **/1712      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]>;1713      /**1714       * Mint an item within a collection.1715       * 1716       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1717       * 1718       * # Permissions1719       * 1720       * * Collection owner1721       * * Collection admin1722       * * Anyone if1723       * * Allow List is enabled, and1724       * * Address is added to allow list, and1725       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1726       * 1727       * # Arguments1728       * 1729       * * `collection_id`: ID of the collection to which an item would belong.1730       * * `owner`: Address of the initial owner of the item.1731       * * `data`: Token data describing the item to store on chain.1732       **/1733      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]>;1734      /**1735       * Create multiple items within a collection.1736       * 1737       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1738       * 1739       * # Permissions1740       * 1741       * * Collection owner1742       * * Collection admin1743       * * Anyone if1744       * * Allow List is enabled, and1745       * * Address is added to the allow list, and1746       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1747       * 1748       * # Arguments1749       * 1750       * * `collection_id`: ID of the collection to which the tokens would belong.1751       * * `owner`: Address of the initial owner of the tokens.1752       * * `items_data`: Vector of data describing each item to be created.1753       **/1754      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>]>;1755      /**1756       * Create multiple items within a collection with explicitly specified initial parameters.1757       * 1758       * # Permissions1759       * 1760       * * Collection owner1761       * * Collection admin1762       * * Anyone if1763       * * Allow List is enabled, and1764       * * Address is added to allow list, and1765       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1766       * 1767       * # Arguments1768       * 1769       * * `collection_id`: ID of the collection to which the tokens would belong.1770       * * `data`: Explicit item creation data.1771       **/1772      createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1773      /**1774       * Delete specified collection properties.1775       * 1776       * # Permissions1777       * 1778       * * Collection Owner1779       * * Collection Admin1780       * 1781       * # Arguments1782       * 1783       * * `collection_id`: ID of the modified collection.1784       * * `property_keys`: Vector of keys of the properties to be deleted.1785       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1786       **/1787      deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1788      /**1789       * Delete specified token properties. Currently properties only work with NFTs.1790       * 1791       * # Permissions1792       * 1793       * * Depends on collection's token property permissions and specified property mutability:1794       * * Collection owner1795       * * Collection admin1796       * * Token owner1797       * 1798       * # Arguments1799       * 1800       * * `collection_id`: ID of the collection to which the token belongs.1801       * * `token_id`: ID of the modified token.1802       * * `property_keys`: Vector of keys of the properties to be deleted.1803       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1804       **/1805      deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1806      /**1807       * Destroy a collection if no tokens exist within.1808       * 1809       * # Permissions1810       * 1811       * * Collection owner1812       * 1813       * # Arguments1814       * 1815       * * `collection_id`: Collection to destroy.1816       **/1817      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1818      /**1819       * Repairs a collection if the data was somehow corrupted.1820       * 1821       * # Arguments1822       * 1823       * * `collection_id`: ID of the collection to repair.1824       **/1825      forceRepairCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1826      /**1827       * Repairs a token if the data was somehow corrupted.1828       * 1829       * # Arguments1830       * 1831       * * `collection_id`: ID of the collection the item belongs to.1832       * * `item_id`: ID of the item.1833       **/1834      forceRepairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1835      /**1836       * Remove admin of a collection.1837       * 1838       * An admin address can remove itself. List of admins may become empty,1839       * in which case only Collection Owner will be able to add an Admin.1840       * 1841       * # Permissions1842       * 1843       * * Collection owner1844       * * Collection admin1845       * 1846       * # Arguments1847       * 1848       * * `collection_id`: ID of the collection to remove the admin for.1849       * * `account_id`: Address of the admin to remove.1850       **/1851      removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1852      /**1853       * Remove a collection's a sponsor, making everyone pay for their own transactions.1854       * 1855       * # Permissions1856       * 1857       * * Collection owner1858       * 1859       * # Arguments1860       * 1861       * * `collection_id`: ID of the collection with the sponsor to remove.1862       **/1863      removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1864      /**1865       * Remove an address from allow list.1866       * 1867       * # Permissions1868       * 1869       * * Collection owner1870       * * Collection admin1871       * 1872       * # Arguments1873       * 1874       * * `collection_id`: ID of the modified collection.1875       * * `address`: ID of the address to be removed from the allowlist.1876       **/1877      removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1878      /**1879       * Re-partition a refungible token, while owning all of its parts/pieces.1880       * 1881       * # Permissions1882       * 1883       * * Token owner (must own every part)1884       * 1885       * # Arguments1886       * 1887       * * `collection_id`: ID of the collection the RFT belongs to.1888       * * `token_id`: ID of the RFT.1889       * * `amount`: New number of parts/pieces into which the token shall be partitioned.1890       **/1891      repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1892      /**1893       * Sets or unsets the approval of a given operator.1894       * 1895       * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1896       * 1897       * # Arguments1898       * 1899       * * `owner`: Token owner1900       * * `operator`: Operator1901       * * `approve`: Should operator status be granted or revoked?1902       **/1903      setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1904      /**1905       * Set specific limits of a collection. Empty, or None fields mean chain default.1906       * 1907       * # Permissions1908       * 1909       * * Collection owner1910       * * Collection admin1911       * 1912       * # Arguments1913       * 1914       * * `collection_id`: ID of the modified collection.1915       * * `new_limit`: New limits of the collection. Fields that are not set (None)1916       * will not overwrite the old ones.1917       **/1918      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]>;1919      /**1920       * Set specific permissions of a collection. Empty, or None fields mean chain default.1921       * 1922       * # Permissions1923       * 1924       * * Collection owner1925       * * Collection admin1926       * 1927       * # Arguments1928       * 1929       * * `collection_id`: ID of the modified collection.1930       * * `new_permission`: New permissions of the collection. Fields that are not set (None)1931       * will not overwrite the old ones.1932       **/1933      setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1934      /**1935       * Add or change collection properties.1936       * 1937       * # Permissions1938       * 1939       * * Collection owner1940       * * Collection admin1941       * 1942       * # Arguments1943       * 1944       * * `collection_id`: ID of the modified collection.1945       * * `properties`: Vector of key-value pairs stored as the collection's metadata.1946       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1947       **/1948      setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1949      /**1950       * Set (invite) a new collection sponsor.1951       * 1952       * If successful, confirmation from the sponsor-to-be will be pending.1953       * 1954       * # Permissions1955       * 1956       * * Collection owner1957       * * Collection admin1958       * 1959       * # Arguments1960       * 1961       * * `collection_id`: ID of the modified collection.1962       * * `new_sponsor`: ID of the account of the sponsor-to-be.1963       **/1964      setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1965      /**1966       * Add or change token properties according to collection's permissions.1967       * Currently properties only work with NFTs.1968       * 1969       * # Permissions1970       * 1971       * * Depends on collection's token property permissions and specified property mutability:1972       * * Collection owner1973       * * Collection admin1974       * * Token owner1975       * 1976       * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1977       * 1978       * # Arguments1979       * 1980       * * `collection_id: ID of the collection to which the token belongs.1981       * * `token_id`: ID of the modified token.1982       * * `properties`: Vector of key-value pairs stored as the token's metadata.1983       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1984       **/1985      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>]>;1986      /**1987       * Add or change token property permissions of a collection.1988       * 1989       * Without a permission for a particular key, a property with that key1990       * cannot be created in a token.1991       * 1992       * # Permissions1993       * 1994       * * Collection owner1995       * * Collection admin1996       * 1997       * # Arguments1998       * 1999       * * `collection_id`: ID of the modified collection.2000       * * `property_permissions`: Vector of permissions for property keys.2001       * Keys support Latin letters, `-`, `_`, and `.` as symbols.2002       **/2003      setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;2004      /**2005       * Completely allow or disallow transfers for a particular collection.2006       * 2007       * # Permissions2008       * 2009       * * Collection owner2010       * 2011       * # Arguments2012       * 2013       * * `collection_id`: ID of the collection.2014       * * `value`: New value of the flag, are transfers allowed?2015       **/2016      setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;2017      /**2018       * Change ownership of the token.2019       * 2020       * # Permissions2021       * 2022       * * Collection owner2023       * * Collection admin2024       * * Current token owner2025       * 2026       * # Arguments2027       * 2028       * * `recipient`: Address of token recipient.2029       * * `collection_id`: ID of the collection the item belongs to.2030       * * `item_id`: ID of the item.2031       * * Non-Fungible Mode: Required.2032       * * Fungible Mode: Ignored.2033       * * Re-Fungible Mode: Required.2034       * 2035       * * `value`: Amount to transfer.2036       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.2037       * * Fungible Mode: The desired number of pieces to transfer.2038       * * Re-Fungible Mode: The desired number of pieces to transfer.2039       **/2040      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]>;2041      /**2042       * Change ownership of an item on behalf of the owner as a non-owner account.2043       * 2044       * See the [`approve`][`Pallet::approve`] method for additional information.2045       * 2046       * After this method executes, one approval is removed from the total so that2047       * the approved address will not be able to transfer this item again from this owner.2048       * 2049       * # Permissions2050       * 2051       * * Collection owner2052       * * Collection admin2053       * * Current item owner2054       * * Address approved by current item owner2055       * 2056       * # Arguments2057       * 2058       * * `from`: Address that currently owns the token.2059       * * `recipient`: Address of the new token-owner-to-be.2060       * * `collection_id`: ID of the collection the item.2061       * * `item_id`: ID of the item to be transferred.2062       * * `value`: Amount to transfer.2063       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.2064       * * Fungible Mode: The desired number of pieces to transfer.2065       * * Re-Fungible Mode: The desired number of pieces to transfer.2066       **/2067      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]>;2068      /**2069       * Generic tx2070       **/2071      [key: string]: SubmittableExtrinsicFunction<ApiType>;2072    };2073    vesting: {2074      claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;2075      claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;2076      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>]>;2077      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]>;2078      /**2079       * Generic tx2080       **/2081      [key: string]: SubmittableExtrinsicFunction<ApiType>;2082    };2083    xcmpQueue: {2084      /**2085       * Resumes all XCM executions for the XCMP queue.2086       * 2087       * Note that this function doesn't change the status of the in/out bound channels.2088       * 2089       * - `origin`: Must pass `ControllerOrigin`.2090       **/2091      resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;2092      /**2093       * Services a single overweight XCM.2094       * 2095       * - `origin`: Must pass `ExecuteOverweightOrigin`.2096       * - `index`: The index of the overweight XCM to service2097       * - `weight_limit`: The amount of weight that XCM execution may take.2098       * 2099       * Errors:2100       * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.2101       * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.2102       * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.2103       * 2104       * Events:2105       * - `OverweightServiced`: On success.2106       **/2107      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;2108      /**2109       * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.2110       * 2111       * - `origin`: Must pass `ControllerOrigin`.2112       **/2113      suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;2114      /**2115       * Overwrites the number of pages of messages which must be in the queue after which we drop any further2116       * messages from the channel.2117       * 2118       * - `origin`: Must pass `Root`.2119       * - `new`: Desired value for `QueueConfigData.drop_threshold`2120       **/2121      updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;2122      /**2123       * Overwrites the number of pages of messages which the queue must be reduced to before it signals that2124       * message sending may recommence after it has been suspended.2125       * 2126       * - `origin`: Must pass `Root`.2127       * - `new`: Desired value for `QueueConfigData.resume_threshold`2128       **/2129      updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;2130      /**2131       * Overwrites the number of pages of messages which must be in the queue for the other side to be told to2132       * suspend their sending.2133       * 2134       * - `origin`: Must pass `Root`.2135       * - `new`: Desired value for `QueueConfigData.suspend_value`2136       **/2137      updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;2138      /**2139       * Overwrites the amount of remaining weight under which we stop processing messages.2140       * 2141       * - `origin`: Must pass `Root`.2142       * - `new`: Desired value for `QueueConfigData.threshold_weight`2143       **/2144      updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;2145      /**2146       * Overwrites the speed to which the available weight approaches the maximum weight.2147       * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.2148       * 2149       * - `origin`: Must pass `Root`.2150       * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.2151       **/2152      updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;2153      /**2154       * Overwrite the maximum amount of weight any individual message may consume.2155       * Messages above this weight go into the overweight queue and may only be serviced explicitly.2156       * 2157       * - `origin`: Must pass `Root`.2158       * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.2159       **/2160      updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;2161      /**2162       * Generic tx2163       **/2164      [key: string]: SubmittableExtrinsicFunction<ApiType>;2165    };2166    xTokens: {2167      /**2168       * Transfer native currencies.2169       * 2170       * `dest_weight_limit` is the weight for XCM execution on the dest2171       * chain, and it would be charged from the transferred assets. If set2172       * below requirements, the execution may fail and assets wouldn't be2173       * received.2174       * 2175       * It's a no-op if any error on local XCM execution or message sending.2176       * Note sending assets out per se doesn't guarantee they would be2177       * received. Receiving depends on if the XCM message could be delivered2178       * by the network, and if the receiving chain would handle2179       * messages correctly.2180       **/2181      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]>;2182      /**2183       * Transfer `MultiAsset`.2184       * 2185       * `dest_weight_limit` is the weight for XCM execution on the dest2186       * chain, and it would be charged from the transferred assets. If set2187       * below requirements, the execution may fail and assets wouldn't be2188       * received.2189       * 2190       * It's a no-op if any error on local XCM execution or message sending.2191       * Note sending assets out per se doesn't guarantee they would be2192       * received. Receiving depends on if the XCM message could be delivered2193       * by the network, and if the receiving chain would handle2194       * messages correctly.2195       **/2196      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]>;2197      /**2198       * Transfer several `MultiAsset` specifying the item to be used as fee2199       * 2200       * `dest_weight_limit` is the weight for XCM execution on the dest2201       * chain, and it would be charged from the transferred assets. If set2202       * below requirements, the execution may fail and assets wouldn't be2203       * received.2204       * 2205       * `fee_item` is index of the MultiAssets that we want to use for2206       * payment2207       * 2208       * It's a no-op if any error on local XCM execution or message sending.2209       * Note sending assets out per se doesn't guarantee they would be2210       * received. Receiving depends on if the XCM message could be delivered2211       * by the network, and if the receiving chain would handle2212       * messages correctly.2213       **/2214      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]>;2215      /**2216       * Transfer `MultiAsset` specifying the fee and amount as separate.2217       * 2218       * `dest_weight_limit` is the weight for XCM execution on the dest2219       * chain, and it would be charged from the transferred assets. If set2220       * below requirements, the execution may fail and assets wouldn't be2221       * received.2222       * 2223       * `fee` is the multiasset to be spent to pay for execution in2224       * destination chain. Both fee and amount will be subtracted form the2225       * callers balance For now we only accept fee and asset having the same2226       * `MultiLocation` id.2227       * 2228       * If `fee` is not high enough to cover for the execution costs in the2229       * destination chain, then the assets will be trapped in the2230       * destination chain2231       * 2232       * It's a no-op if any error on local XCM execution or message sending.2233       * Note sending assets out per se doesn't guarantee they would be2234       * received. Receiving depends on if the XCM message could be delivered2235       * by the network, and if the receiving chain would handle2236       * messages correctly.2237       **/2238      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]>;2239      /**2240       * Transfer several currencies specifying the item to be used as fee2241       * 2242       * `dest_weight_limit` is the weight for XCM execution on the dest2243       * chain, and it would be charged from the transferred assets. If set2244       * below requirements, the execution may fail and assets wouldn't be2245       * received.2246       * 2247       * `fee_item` is index of the currencies tuple that we want to use for2248       * payment2249       * 2250       * It's a no-op if any error on local XCM execution or message sending.2251       * Note sending assets out per se doesn't guarantee they would be2252       * received. Receiving depends on if the XCM message could be delivered2253       * by the network, and if the receiving chain would handle2254       * messages correctly.2255       **/2256      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]>;2257      /**2258       * Transfer native currencies specifying the fee and amount as2259       * separate.2260       * 2261       * `dest_weight_limit` is the weight for XCM execution on the dest2262       * chain, and it would be charged from the transferred assets. If set2263       * below requirements, the execution may fail and assets wouldn't be2264       * received.2265       * 2266       * `fee` is the amount to be spent to pay for execution in destination2267       * chain. Both fee and amount will be subtracted form the callers2268       * balance.2269       * 2270       * If `fee` is not high enough to cover for the execution costs in the2271       * destination chain, then the assets will be trapped in the2272       * destination chain2273       * 2274       * It's a no-op if any error on local XCM execution or message sending.2275       * Note sending assets out per se doesn't guarantee they would be2276       * received. Receiving depends on if the XCM message could be delivered2277       * by the network, and if the receiving chain would handle2278       * messages correctly.2279       **/2280      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]>;2281      /**2282       * Generic tx2283       **/2284      [key: string]: SubmittableExtrinsicFunction<ApiType>;2285    };2286  } // AugmentedSubmittables2287} // declare module