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

1// Auto-generated via `yarn polkadot-types-from-chain`, do not edit2/* eslint-disable */34// import type lookup before we augment - in some environments5// this is required to allow for ambient/previous definitions6import '@polkadot/api-base/types/submittable';78import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types';9import type { Bytes, Compact, Option, U256, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';10import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';11import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill } from '@polkadot/types/interfaces/runtime';12import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, FrameSupportScheduleMaybeHashed, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';1314export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;15export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;16export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;1718declare module '@polkadot/api-base/types/submittable' {19  interface AugmentedSubmittables<ApiType extends ApiTypes> {20    balances: {21      /**22       * Exactly as `transfer`, except the origin must be root and the source account may be23       * specified.24       * # <weight>25       * - Same as transfer, but additional read and write because the source account is not26       * assumed to be in the overlay.27       * # </weight>28       **/29      forceTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, Compact<u128>]>;30      /**31       * Unreserve some balance from a user by force.32       * 33       * Can only be called by ROOT.34       **/35      forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;36      /**37       * Set the balances of a given account.38       * 39       * This will alter `FreeBalance` and `ReservedBalance` in storage. it will40       * also alter the total issuance of the system (`TotalIssuance`) appropriately.41       * If the new free or reserved balance is below the existential deposit,42       * it will reset the account nonce (`frame_system::AccountNonce`).43       * 44       * The dispatch origin for this call is `root`.45       **/46      setBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, newReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>, Compact<u128>]>;47      /**48       * Transfer some liquid free balance to another account.49       * 50       * `transfer` will set the `FreeBalance` of the sender and receiver.51       * If the sender's account is below the existential deposit as a result52       * of the transfer, the account will be reaped.53       * 54       * The dispatch origin for this call must be `Signed` by the transactor.55       * 56       * # <weight>57       * - Dependent on arguments but not critical, given proper implementations for input config58       * types. See related functions below.59       * - It contains a limited number of reads and writes internally and no complex60       * computation.61       * 62       * Related functions:63       * 64       * - `ensure_can_withdraw` is always called internally but has a bounded complexity.65       * - Transferring balances to accounts that did not exist before will cause66       * `T::OnNewAccount::on_new_account` to be called.67       * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.68       * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check69       * that the transfer will not kill the origin account.70       * ---------------------------------71       * - Origin account is already in memory, so no DB operations for them.72       * # </weight>73       **/74      transfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;75      /**76       * Transfer the entire transferable balance from the caller account.77       * 78       * NOTE: This function only attempts to transfer _transferable_ balances. This means that79       * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be80       * transferred by this function. To ensure that this function results in a killed account,81       * you might need to prepare the account by removing any reference counters, storage82       * deposits, etc...83       * 84       * The dispatch origin of this call must be Signed.85       * 86       * - `dest`: The recipient of the transfer.87       * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all88       * of the funds the account has, causing the sender account to be killed (false), or89       * transfer everything except at least the existential deposit, which will guarantee to90       * keep the sender account alive (true). # <weight>91       * - O(1). Just like transfer, but reading the user's transferable balance first.92       * #</weight>93       **/94      transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;95      /**96       * Same as the [`transfer`] call, but with a check that the transfer will not kill the97       * origin account.98       * 99       * 99% of the time you want [`transfer`] instead.100       * 101       * [`transfer`]: struct.Pallet.html#method.transfer102       **/103      transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;104      /**105       * Generic tx106       **/107      [key: string]: SubmittableExtrinsicFunction<ApiType>;108    };109    charging: {110      /**111       * Generic tx112       **/113      [key: string]: SubmittableExtrinsicFunction<ApiType>;114    };115    configuration: {116      setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;117      setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;118      /**119       * Generic tx120       **/121      [key: string]: SubmittableExtrinsicFunction<ApiType>;122    };123    cumulusXcm: {124      /**125       * Generic tx126       **/127      [key: string]: SubmittableExtrinsicFunction<ApiType>;128    };129    dmpQueue: {130      /**131       * Service a single overweight message.132       * 133       * - `origin`: Must pass `ExecuteOverweightOrigin`.134       * - `index`: The index of the overweight message to service.135       * - `weight_limit`: The amount of weight that message execution may take.136       * 137       * Errors:138       * - `Unknown`: Message of `index` is unknown.139       * - `OverLimit`: Message execution may use greater than `weight_limit`.140       * 141       * Events:142       * - `OverweightServiced`: On success.143       **/144      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;145      /**146       * Generic tx147       **/148      [key: string]: SubmittableExtrinsicFunction<ApiType>;149    };150    ethereum: {151      /**152       * Transact an Ethereum transaction.153       **/154      transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;155      /**156       * Generic tx157       **/158      [key: string]: SubmittableExtrinsicFunction<ApiType>;159    };160    evm: {161      /**162       * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.163       **/164      call: AugmentedSubmittable<(source: H160 | string | Uint8Array, target: H160 | string | Uint8Array, input: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, H160, Bytes, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;165      /**166       * Issue an EVM create operation. This is similar to a contract creation transaction in167       * Ethereum.168       **/169      create: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, Bytes, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;170      /**171       * Issue an EVM create2 operation.172       **/173      create2: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, salt: H256 | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, Bytes, H256, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;174      /**175       * Withdraw balance from EVM into currency/balances pallet.176       **/177      withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;178      /**179       * Generic tx180       **/181      [key: string]: SubmittableExtrinsicFunction<ApiType>;182    };183    evmMigration: {184      begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;185      finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;186      setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;187      /**188       * Generic tx189       **/190      [key: string]: SubmittableExtrinsicFunction<ApiType>;191    };192    inflation: {193      /**194       * This method sets the inflation start date. Can be only called once.195       * Inflation start block can be backdated and will catch up. The method will create Treasury196       * account if it does not exist and perform the first inflation deposit.197       * 198       * # Permissions199       * 200       * * Root201       * 202       * # Arguments203       * 204       * * inflation_start_relay_block: The relay chain block at which inflation should start205       **/206      startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;207      /**208       * Generic tx209       **/210      [key: string]: SubmittableExtrinsicFunction<ApiType>;211    };212    parachainSystem: {213      authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;214      enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;215      /**216       * Set the current validation data.217       * 218       * This should be invoked exactly once per block. It will panic at the finalization219       * phase if the call was not invoked.220       * 221       * The dispatch origin for this call must be `Inherent`222       * 223       * As a side effect, this function upgrades the current validation function224       * if the appropriate time has come.225       **/226      setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;227      sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;228      /**229       * Generic tx230       **/231      [key: string]: SubmittableExtrinsicFunction<ApiType>;232    };233    polkadotXcm: {234      /**235       * Execute an XCM message from a local, signed, origin.236       * 237       * An event is deposited indicating whether `msg` could be executed completely or only238       * partially.239       * 240       * No more than `max_weight` will be used in its attempted execution. If this is less than the241       * maximum amount of weight that the message could take to be executed, then no execution242       * attempt will be made.243       * 244       * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully245       * to completion; only that *some* of it was executed.246       **/247      execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;248      /**249       * Set a safe XCM version (the version that XCM should be encoded with if the most recent250       * version a destination can accept is unknown).251       * 252       * - `origin`: Must be Root.253       * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.254       **/255      forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;256      /**257       * Ask a location to notify us regarding their XCM version and any changes to it.258       * 259       * - `origin`: Must be Root.260       * - `location`: The location to which we should subscribe for XCM version notifications.261       **/262      forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;263      /**264       * Require that a particular destination should no longer notify us regarding any XCM265       * version changes.266       * 267       * - `origin`: Must be Root.268       * - `location`: The location to which we are currently subscribed for XCM version269       * notifications which we no longer desire.270       **/271      forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;272      /**273       * Extoll that a particular destination can be communicated with through a particular274       * version of XCM.275       * 276       * - `origin`: Must be Root.277       * - `location`: The destination that is being described.278       * - `xcm_version`: The latest version of XCM that `location` supports.279       **/280      forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;281      /**282       * Transfer some assets from the local chain to the sovereign account of a destination283       * chain and forward a notification XCM.284       * 285       * Fee payment on the destination side is made from the asset in the `assets` vector of286       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight287       * is needed than `weight_limit`, then the operation will fail and the assets send may be288       * at risk.289       * 290       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.291       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send292       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.293       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be294       * an `AccountId32` value.295       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the296       * `dest` side.297       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay298       * fees.299       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.300       **/301      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]>;302      /**303       * Teleport some assets from the local chain to some destination chain.304       * 305       * Fee payment on the destination side is made from the asset in the `assets` vector of306       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight307       * is needed than `weight_limit`, then the operation will fail and the assets send may be308       * at risk.309       * 310       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.311       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send312       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.313       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be314       * an `AccountId32` value.315       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the316       * `dest` side. May not be empty.317       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay318       * fees.319       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.320       **/321      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]>;322      /**323       * Transfer some assets from the local chain to the sovereign account of a destination324       * chain and forward a notification XCM.325       * 326       * Fee payment on the destination side is made from the asset in the `assets` vector of327       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,328       * with all fees taken as needed from the asset.329       * 330       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.331       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send332       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.333       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be334       * an `AccountId32` value.335       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the336       * `dest` side.337       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay338       * fees.339       **/340      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]>;341      send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;342      /**343       * Teleport some assets from the local chain to some destination chain.344       * 345       * Fee payment on the destination side is made from the asset in the `assets` vector of346       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,347       * with all fees taken as needed from the asset.348       * 349       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.350       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send351       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.352       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be353       * an `AccountId32` value.354       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the355       * `dest` side. May not be empty.356       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay357       * fees.358       **/359      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]>;360      /**361       * Generic tx362       **/363      [key: string]: SubmittableExtrinsicFunction<ApiType>;364    };365    promotion: {366      payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;367      setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;368      sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;369      sponsorConract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;370      stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;371      startAppPromotion: AugmentedSubmittable<(promotionStartRelayBlock: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;372      stopAppPromotion: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;373      stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;374      stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;375      unstake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;376      /**377       * Generic tx378       **/379      [key: string]: SubmittableExtrinsicFunction<ApiType>;380    };381    rmrkCore: {382      /**383       * Accept an NFT sent from another account to self or an owned NFT.384       * 385       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.386       * 387       * # Permissions:388       * - Token-owner-to-be389       * 390       * # Arguments:391       * - `origin`: sender of the transaction392       * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.393       * - `rmrk_nft_id`: ID of the NFT to be accepted.394       * - `new_owner`: Either the sender's account ID or a sender-owned NFT,395       * whichever the accepted NFT was sent to.396       **/397      acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;398      /**399       * Accept the addition of a newly created pending resource to an existing NFT.400       * 401       * This transaction is needed when a resource is created and assigned to an NFT402       * by a non-owner, i.e. the collection issuer, with one of the403       * [`add_...` transactions](Pallet::add_basic_resource).404       * 405       * # Permissions:406       * - Token owner407       * 408       * # Arguments:409       * - `origin`: sender of the transaction410       * - `rmrk_collection_id`: RMRK collection ID of the NFT.411       * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.412       * - `resource_id`: ID of the newly created pending resource.413       * accept the addition of a new resource to an existing NFT414       **/415      acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;416      /**417       * Accept the removal of a removal-pending resource from an NFT.418       * 419       * This transaction is needed when a non-owner, i.e. the collection issuer,420       * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.421       * 422       * # Permissions:423       * - Token owner424       * 425       * # Arguments:426       * - `origin`: sender of the transaction427       * - `rmrk_collection_id`: RMRK collection ID of the NFT.428       * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.429       * - `resource_id`: ID of the removal-pending resource.430       **/431      acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;432      /**433       * Create and set/propose a basic resource for an NFT.434       * 435       * A basic resource is the simplest, lacking a Base and anything that comes with it.436       * See RMRK docs for more information and examples.437       * 438       * # Permissions:439       * - Collection issuer - if not the token owner, adding the resource will warrant440       * the owner's [acceptance](Pallet::accept_resource).441       * 442       * # Arguments:443       * - `origin`: sender of the transaction444       * - `rmrk_collection_id`: RMRK collection ID of the NFT.445       * - `nft_id`: ID of the NFT to assign a resource to.446       * - `resource`: Data of the resource to be created.447       **/448      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]>;449      /**450       * Create and set/propose a composable resource for an NFT.451       * 452       * A composable resource links to a Base and has a subset of its Parts it is composed of.453       * See RMRK docs for more information and examples.454       * 455       * # Permissions:456       * - Collection issuer - if not the token owner, adding the resource will warrant457       * the owner's [acceptance](Pallet::accept_resource).458       * 459       * # Arguments:460       * - `origin`: sender of the transaction461       * - `rmrk_collection_id`: RMRK collection ID of the NFT.462       * - `nft_id`: ID of the NFT to assign a resource to.463       * - `resource`: Data of the resource to be created.464       **/465      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]>;466      /**467       * Create and set/propose a slot resource for an NFT.468       * 469       * A slot resource links to a Base and a slot ID in it which it can fit into.470       * See RMRK docs for more information and examples.471       * 472       * # Permissions:473       * - Collection issuer - if not the token owner, adding the resource will warrant474       * the owner's [acceptance](Pallet::accept_resource).475       * 476       * # Arguments:477       * - `origin`: sender of the transaction478       * - `rmrk_collection_id`: RMRK collection ID of the NFT.479       * - `nft_id`: ID of the NFT to assign a resource to.480       * - `resource`: Data of the resource to be created.481       **/482      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]>;483      /**484       * Burn an NFT, destroying it and its nested tokens up to the specified limit.485       * If the burning budget is exceeded, the transaction is reverted.486       * 487       * This is the way to burn a nested token as well.488       * 489       * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).490       * 491       * # Permissions:492       * * Token owner493       * 494       * # Arguments:495       * - `origin`: sender of the transaction496       * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.497       * - `nft_id`: ID of the NFT to be destroyed.498       * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction499       * is reverted if there are more tokens to burn in the nesting tree than this number.500       * This is primarily a mechanism of transaction weight control.501       **/502      burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;503      /**504       * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).505       * 506       * # Permissions:507       * * Collection issuer508       * 509       * # Arguments:510       * - `origin`: sender of the transaction511       * - `collection_id`: RMRK collection ID to change the issuer of.512       * - `new_issuer`: Collection's new issuer.513       **/514      changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;515      /**516       * Create a new collection of NFTs.517       * 518       * # Permissions:519       * * Anyone - will be assigned as the issuer of the collection.520       * 521       * # Arguments:522       * - `origin`: sender of the transaction523       * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.524       * - `max`: Optional maximum number of tokens.525       * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.526       * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.527       **/528      createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;529      /**530       * Destroy a collection.531       * 532       * Only empty collections can be destroyed. If it has any tokens, they must be burned first.533       * 534       * # Permissions:535       * * Collection issuer536       * 537       * # Arguments:538       * - `origin`: sender of the transaction539       * - `collection_id`: RMRK ID of the collection to destroy.540       **/541      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;542      /**543       * "Lock" the collection and prevent new token creation. Cannot be undone.544       * 545       * # Permissions:546       * * Collection issuer547       * 548       * # Arguments:549       * - `origin`: sender of the transaction550       * - `collection_id`: RMRK ID of the collection to lock.551       **/552      lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;553      /**554       * Mint an NFT in a specified collection.555       * 556       * # Permissions:557       * * Collection issuer558       * 559       * # Arguments:560       * - `origin`: sender of the transaction561       * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).562       * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.563       * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.564       * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.565       * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.566       * - `transferable`: Can this NFT be transferred? Cannot be changed.567       * - `resources`: Resource data to be added to the NFT immediately after minting.568       **/569      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>>]>;570      /**571       * Reject an NFT sent from another account to self or owned NFT.572       * The NFT in question will not be sent back and burnt instead.573       * 574       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.575       * 576       * # Permissions:577       * - Token-owner-to-be-not578       * 579       * # Arguments:580       * - `origin`: sender of the transaction581       * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.582       * - `rmrk_nft_id`: ID of the NFT to be rejected.583       **/584      rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;585      /**586       * Remove and erase a resource from an NFT.587       * 588       * If the sender does not own the NFT, then it will be pending confirmation,589       * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.590       * 591       * # Permissions592       * - Collection issuer593       * 594       * # Arguments595       * - `origin`: sender of the transaction596       * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.597       * - `nft_id`: ID of the NFT with a resource to be removed.598       * - `resource_id`: ID of the resource to be removed.599       **/600      removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;601      /**602       * Transfer an NFT from an account/NFT A to another account/NFT B.603       * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].604       * 605       * If the target owner is an NFT owned by another account, then the NFT will enter606       * the pending state and will have to be accepted by the other account.607       * 608       * # Permissions:609       * - Token owner610       * 611       * # Arguments:612       * - `origin`: sender of the transaction613       * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.614       * - `rmrk_nft_id`: ID of the NFT to be transferred.615       * - `new_owner`: New owner of the nft which can be either an account or a NFT.616       **/617      send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;618      /**619       * Set a different order of resource priorities for an NFT. Priorities can be used,620       * for example, for order of rendering.621       * 622       * Note that the priorities are not updated automatically, and are an empty vector623       * by default. There is no pre-set definition for the order to be particular,624       * it can be interpreted arbitrarily use-case by use-case.625       * 626       * # Permissions:627       * - Token owner628       * 629       * # Arguments:630       * - `origin`: sender of the transaction631       * - `rmrk_collection_id`: RMRK collection ID of the NFT.632       * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.633       * - `priorities`: Ordered vector of resource IDs.634       **/635      setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;636      /**637       * Add or edit a custom user property, a key-value pair, describing the metadata638       * of a token or a collection, on either one of these.639       * 640       * Note that in this proxy implementation many details regarding RMRK are stored641       * as scoped properties prefixed with "rmrk:", normally inaccessible642       * to external transactions and RPCs.643       * 644       * # Permissions:645       * - Collection issuer - in case of collection property646       * - Token owner - in case of NFT property647       * 648       * # Arguments:649       * - `origin`: sender of the transaction650       * - `rmrk_collection_id`: RMRK collection ID.651       * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.652       * - `key`: Key of the custom property to be referenced by.653       * - `value`: Value of the custom property to be stored.654       **/655      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]>;656      /**657       * Generic tx658       **/659      [key: string]: SubmittableExtrinsicFunction<ApiType>;660    };661    rmrkEquip: {662      /**663       * Create a new Base.664       * 665       * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)666       * 667       * # Permissions668       * - Anyone - will be assigned as the issuer of the Base.669       * 670       * # Arguments:671       * - `origin`: Caller, will be assigned as the issuer of the Base672       * - `base_type`: Arbitrary media type, e.g. "svg".673       * - `symbol`: Arbitrary client-chosen symbol.674       * - `parts`: Array of Fixed and Slot Parts composing the Base,675       * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).676       **/677      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>]>;678      /**679       * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.680       * 681       * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).682       * 683       * # Permissions:684       * - Base issuer685       * 686       * # Arguments:687       * - `origin`: sender of the transaction688       * - `base_id`: Base containing the Slot Part to be updated.689       * - `slot_id`: Slot Part whose Equippable List is being updated .690       * - `equippables`: List of equippables that will override the current Equippables list.691       **/692      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]>;693      /**694       * Add a Theme to a Base.695       * A Theme named "default" is required prior to adding other Themes.696       * 697       * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).698       * 699       * # Permissions:700       * - Base issuer701       * 702       * # Arguments:703       * - `origin`: sender of the transaction704       * - `base_id`: Base ID containing the Theme to be updated.705       * - `theme`: Theme to add to the Base.  A Theme has a name and properties, which are an706       * array of [key, value, inherit].707       * - `key`: Arbitrary BoundedString, defined by client.708       * - `value`: Arbitrary BoundedString, defined by client.709       * - `inherit`: Optional bool.710       **/711      themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;712      /**713       * Generic tx714       **/715      [key: string]: SubmittableExtrinsicFunction<ApiType>;716    };717    scheduler: {718      /**719       * Cancel a named scheduled task.720       **/721      cancelNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed]>;722      /**723       * Schedule a named task.724       **/725      scheduleNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, FrameSupportScheduleMaybeHashed]>;726      /**727       * Schedule a named task after a delay.728       * 729       * # <weight>730       * Same as [`schedule_named`](Self::schedule_named).731       * # </weight>732       **/733      scheduleNamedAfter: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, FrameSupportScheduleMaybeHashed]>;734      /**735       * Generic tx736       **/737      [key: string]: SubmittableExtrinsicFunction<ApiType>;738    };739    structure: {740      /**741       * Generic tx742       **/743      [key: string]: SubmittableExtrinsicFunction<ApiType>;744    };745    sudo: {746      /**747       * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo748       * key.749       * 750       * The dispatch origin for this call must be _Signed_.751       * 752       * # <weight>753       * - O(1).754       * - Limited storage reads.755       * - One DB change.756       * # </weight>757       **/758      setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;759      /**760       * Authenticates the sudo key and dispatches a function call with `Root` origin.761       * 762       * The dispatch origin for this call must be _Signed_.763       * 764       * # <weight>765       * - O(1).766       * - Limited storage reads.767       * - One DB write (event).768       * - Weight of derivative `call` execution + 10,000.769       * # </weight>770       **/771      sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;772      /**773       * Authenticates the sudo key and dispatches a function call with `Signed` origin from774       * a given account.775       * 776       * The dispatch origin for this call must be _Signed_.777       * 778       * # <weight>779       * - O(1).780       * - Limited storage reads.781       * - One DB write (event).782       * - Weight of derivative `call` execution + 10,000.783       * # </weight>784       **/785      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]>;786      /**787       * Authenticates the sudo key and dispatches a function call with `Root` origin.788       * This function does not check the weight of the call, and instead allows the789       * Sudo user to specify the weight of the call.790       * 791       * The dispatch origin for this call must be _Signed_.792       * 793       * # <weight>794       * - O(1).795       * - The weight of this call is defined by the caller.796       * # </weight>797       **/798      sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, u64]>;799      /**800       * Generic tx801       **/802      [key: string]: SubmittableExtrinsicFunction<ApiType>;803    };804    system: {805      /**806       * A dispatch that will fill the block weight up to the given ratio.807       **/808      fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;809      /**810       * Kill all storage items with a key that starts with the given prefix.811       * 812       * **NOTE:** We rely on the Root origin to provide us the number of subkeys under813       * the prefix we are removing to accurately calculate the weight of this function.814       **/815      killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;816      /**817       * Kill some items from storage.818       **/819      killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;820      /**821       * Make some on-chain remark.822       * 823       * # <weight>824       * - `O(1)`825       * # </weight>826       **/827      remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;828      /**829       * Make some on-chain remark and emit event.830       **/831      remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;832      /**833       * Set the new runtime code.834       * 835       * # <weight>836       * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`837       * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is838       * expensive).839       * - 1 storage write (codec `O(C)`).840       * - 1 digest item.841       * - 1 event.842       * The weight of this function is dependent on the runtime, but generally this is very843       * expensive. We will treat this as a full block.844       * # </weight>845       **/846      setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;847      /**848       * Set the new runtime code without doing any checks of the given `code`.849       * 850       * # <weight>851       * - `O(C)` where `C` length of `code`852       * - 1 storage write (codec `O(C)`).853       * - 1 digest item.854       * - 1 event.855       * The weight of this function is dependent on the runtime. We will treat this as a full856       * block. # </weight>857       **/858      setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;859      /**860       * Set the number of pages in the WebAssembly environment's heap.861       **/862      setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;863      /**864       * Set some items of storage.865       **/866      setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;867      /**868       * Generic tx869       **/870      [key: string]: SubmittableExtrinsicFunction<ApiType>;871    };872    timestamp: {873      /**874       * Set the current time.875       * 876       * This call should be invoked exactly once per block. It will panic at the finalization877       * phase, if this call hasn't been invoked by that time.878       * 879       * The timestamp should be greater than the previous one by the amount specified by880       * `MinimumPeriod`.881       * 882       * The dispatch origin for this call must be `Inherent`.883       * 884       * # <weight>885       * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)886       * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in887       * `on_finalize`)888       * - 1 event handler `on_timestamp_set`. Must be `O(1)`.889       * # </weight>890       **/891      set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;892      /**893       * Generic tx894       **/895      [key: string]: SubmittableExtrinsicFunction<ApiType>;896    };897    treasury: {898      /**899       * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary900       * and the original deposit will be returned.901       * 902       * May only be called from `T::ApproveOrigin`.903       * 904       * # <weight>905       * - Complexity: O(1).906       * - DbReads: `Proposals`, `Approvals`907       * - DbWrite: `Approvals`908       * # </weight>909       **/910      approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;911      /**912       * Put forward a suggestion for spending. A deposit proportional to the value913       * is reserved and slashed if the proposal is rejected. It is returned once the914       * proposal is awarded.915       * 916       * # <weight>917       * - Complexity: O(1)918       * - DbReads: `ProposalCount`, `origin account`919       * - DbWrites: `ProposalCount`, `Proposals`, `origin account`920       * # </weight>921       **/922      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]>;923      /**924       * Reject a proposed spend. The original deposit will be slashed.925       * 926       * May only be called from `T::RejectOrigin`.927       * 928       * # <weight>929       * - Complexity: O(1)930       * - DbReads: `Proposals`, `rejected proposer account`931       * - DbWrites: `Proposals`, `rejected proposer account`932       * # </weight>933       **/934      rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;935      /**936       * Force a previously approved proposal to be removed from the approval queue.937       * The original deposit will no longer be returned.938       * 939       * May only be called from `T::RejectOrigin`.940       * - `proposal_id`: The index of a proposal941       * 942       * # <weight>943       * - Complexity: O(A) where `A` is the number of approvals944       * - Db reads and writes: `Approvals`945       * # </weight>946       * 947       * Errors:948       * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,949       * i.e., the proposal has not been approved. This could also mean the proposal does not950       * exist altogether, thus there is no way it would have been approved in the first place.951       **/952      removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;953      /**954       * Propose and approve a spend of treasury funds.955       * 956       * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.957       * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.958       * - `beneficiary`: The destination account for the transfer.959       * 960       * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the961       * beneficiary.962       **/963      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]>;964      /**965       * Generic tx966       **/967      [key: string]: SubmittableExtrinsicFunction<ApiType>;968    };969    unique: {970      /**971       * Add an admin to a collection.972       * 973       * NFT Collection can be controlled by multiple admin addresses974       * (some which can also be servers, for example). Admins can issue975       * and burn NFTs, as well as add and remove other admins,976       * but cannot change NFT or Collection ownership.977       * 978       * # Permissions979       * 980       * * Collection owner981       * * Collection admin982       * 983       * # Arguments984       * 985       * * `collection_id`: ID of the Collection to add an admin for.986       * * `new_admin`: Address of new admin to add.987       **/988      addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;989      /**990       * Add an address to allow list.991       * 992       * # Permissions993       * 994       * * Collection owner995       * * Collection admin996       * 997       * # Arguments998       * 999       * * `collection_id`: ID of the modified collection.1000       * * `address`: ID of the address to be added to the allowlist.1001       **/1002      addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1003      /**1004       * Allow a non-permissioned address to transfer or burn an item.1005       * 1006       * # Permissions1007       * 1008       * * Collection owner1009       * * Collection admin1010       * * Current item owner1011       * 1012       * # Arguments1013       * 1014       * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1015       * * `collection_id`: ID of the collection the item belongs to.1016       * * `item_id`: ID of the item transactions on which are now approved.1017       * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1018       * Set to 0 to revoke the approval.1019       **/1020      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]>;1021      /**1022       * Destroy a token on behalf of the owner as a non-owner account.1023       * 1024       * See also: [`approve`][`Pallet::approve`].1025       * 1026       * After this method executes, one approval is removed from the total so that1027       * the approved address will not be able to transfer this item again from this owner.1028       * 1029       * # Permissions1030       * 1031       * * Collection owner1032       * * Collection admin1033       * * Current token owner1034       * * Address approved by current item owner1035       * 1036       * # Arguments1037       * 1038       * * `from`: The owner of the burning item.1039       * * `collection_id`: ID of the collection to which the item belongs.1040       * * `item_id`: ID of item to burn.1041       * * `value`: Number of pieces to burn.1042       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1043       * * Fungible Mode: The desired number of pieces to burn.1044       * * Re-Fungible Mode: The desired number of pieces to burn.1045       **/1046      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]>;1047      /**1048       * Destroy an item.1049       * 1050       * # Permissions1051       * 1052       * * Collection owner1053       * * Collection admin1054       * * Current item owner1055       * 1056       * # Arguments1057       * 1058       * * `collection_id`: ID of the collection to which the item belongs.1059       * * `item_id`: ID of item to burn.1060       * * `value`: Number of pieces of the item to destroy.1061       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1062       * * Fungible Mode: The desired number of pieces to burn.1063       * * Re-Fungible Mode: The desired number of pieces to burn.1064       **/1065      burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1066      /**1067       * Change the owner of the collection.1068       * 1069       * # Permissions1070       * 1071       * * Collection owner1072       * 1073       * # Arguments1074       * 1075       * * `collection_id`: ID of the modified collection.1076       * * `new_owner`: ID of the account that will become the owner.1077       **/1078      changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1079      /**1080       * Confirm own sponsorship of a collection, becoming the sponsor.1081       * 1082       * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1083       * Sponsor can pay the fees of a transaction instead of the sender,1084       * but only within specified limits.1085       * 1086       * # Permissions1087       * 1088       * * Sponsor-to-be1089       * 1090       * # Arguments1091       * 1092       * * `collection_id`: ID of the collection with the pending sponsor.1093       **/1094      confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1095      /**1096       * Create a collection of tokens.1097       * 1098       * Each Token may have multiple properties encoded as an array of bytes1099       * of certain length. The initial owner of the collection is set1100       * to the address that signed the transaction and can be changed later.1101       * 1102       * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1103       * 1104       * # Permissions1105       * 1106       * * Anyone - becomes the owner of the new collection.1107       * 1108       * # Arguments1109       * 1110       * * `collection_name`: Wide-character string with collection name1111       * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1112       * * `collection_description`: Wide-character string with collection description1113       * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1114       * * `token_prefix`: Byte string containing the token prefix to mark a collection1115       * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1116       * * `mode`: Type of items stored in the collection and type dependent data.1117       **/1118      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]>;1119      /**1120       * Create a collection with explicit parameters.1121       * 1122       * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1123       * 1124       * # Permissions1125       * 1126       * * Anyone - becomes the owner of the new collection.1127       * 1128       * # Arguments1129       * 1130       * * `data`: Explicit data of a collection used for its creation.1131       **/1132      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]>;1133      /**1134       * Mint an item within a collection.1135       * 1136       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1137       * 1138       * # Permissions1139       * 1140       * * Collection owner1141       * * Collection admin1142       * * Anyone if1143       * * Allow List is enabled, and1144       * * Address is added to allow list, and1145       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1146       * 1147       * # Arguments1148       * 1149       * * `collection_id`: ID of the collection to which an item would belong.1150       * * `owner`: Address of the initial owner of the item.1151       * * `data`: Token data describing the item to store on chain.1152       **/1153      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]>;1154      /**1155       * Create multiple items within a collection.1156       * 1157       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1158       * 1159       * # Permissions1160       * 1161       * * Collection owner1162       * * Collection admin1163       * * Anyone if1164       * * Allow List is enabled, and1165       * * Address is added to the allow list, and1166       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1167       * 1168       * # Arguments1169       * 1170       * * `collection_id`: ID of the collection to which the tokens would belong.1171       * * `owner`: Address of the initial owner of the tokens.1172       * * `items_data`: Vector of data describing each item to be created.1173       **/1174      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>]>;1175      /**1176       * Create multiple items within a collection with explicitly specified initial parameters.1177       * 1178       * # Permissions1179       * 1180       * * Collection owner1181       * * Collection admin1182       * * Anyone if1183       * * Allow List is enabled, and1184       * * Address is added to allow list, and1185       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1186       * 1187       * # Arguments1188       * 1189       * * `collection_id`: ID of the collection to which the tokens would belong.1190       * * `data`: Explicit item creation data.1191       **/1192      createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1193      /**1194       * Delete specified collection properties.1195       * 1196       * # Permissions1197       * 1198       * * Collection Owner1199       * * Collection Admin1200       * 1201       * # Arguments1202       * 1203       * * `collection_id`: ID of the modified collection.1204       * * `property_keys`: Vector of keys of the properties to be deleted.1205       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1206       **/1207      deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1208      /**1209       * Delete specified token properties. Currently properties only work with NFTs.1210       * 1211       * # Permissions1212       * 1213       * * Depends on collection's token property permissions and specified property mutability:1214       * * Collection owner1215       * * Collection admin1216       * * Token owner1217       * 1218       * # Arguments1219       * 1220       * * `collection_id`: ID of the collection to which the token belongs.1221       * * `token_id`: ID of the modified token.1222       * * `property_keys`: Vector of keys of the properties to be deleted.1223       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1224       **/1225      deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1226      /**1227       * Destroy a collection if no tokens exist within.1228       * 1229       * # Permissions1230       * 1231       * * Collection owner1232       * 1233       * # Arguments1234       * 1235       * * `collection_id`: Collection to destroy.1236       **/1237      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1238      /**1239       * Remove admin of a collection.1240       * 1241       * An admin address can remove itself. List of admins may become empty,1242       * in which case only Collection Owner will be able to add an Admin.1243       * 1244       * # Permissions1245       * 1246       * * Collection owner1247       * * Collection admin1248       * 1249       * # Arguments1250       * 1251       * * `collection_id`: ID of the collection to remove the admin for.1252       * * `account_id`: Address of the admin to remove.1253       **/1254      removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1255      /**1256       * Remove a collection's a sponsor, making everyone pay for their own transactions.1257       * 1258       * # Permissions1259       * 1260       * * Collection owner1261       * 1262       * # Arguments1263       * 1264       * * `collection_id`: ID of the collection with the sponsor to remove.1265       **/1266      removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1267      /**1268       * Remove an address from allow list.1269       * 1270       * # Permissions1271       * 1272       * * Collection owner1273       * * Collection admin1274       * 1275       * # Arguments1276       * 1277       * * `collection_id`: ID of the modified collection.1278       * * `address`: ID of the address to be removed from the allowlist.1279       **/1280      removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1281      /**1282       * Re-partition a refungible token, while owning all of its parts/pieces.1283       * 1284       * # Permissions1285       * 1286       * * Token owner (must own every part)1287       * 1288       * # Arguments1289       * 1290       * * `collection_id`: ID of the collection the RFT belongs to.1291       * * `token_id`: ID of the RFT.1292       * * `amount`: New number of parts/pieces into which the token shall be partitioned.1293       **/1294      repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1295      /**1296       * Set specific limits of a collection. Empty, or None fields mean chain default.1297       * 1298       * # Permissions1299       * 1300       * * Collection owner1301       * * Collection admin1302       * 1303       * # Arguments1304       * 1305       * * `collection_id`: ID of the modified collection.1306       * * `new_limit`: New limits of the collection. Fields that are not set (None)1307       * will not overwrite the old ones.1308       **/1309      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]>;1310      /**1311       * Set specific permissions of a collection. Empty, or None fields mean chain default.1312       * 1313       * # Permissions1314       * 1315       * * Collection owner1316       * * Collection admin1317       * 1318       * # Arguments1319       * 1320       * * `collection_id`: ID of the modified collection.1321       * * `new_permission`: New permissions of the collection. Fields that are not set (None)1322       * will not overwrite the old ones.1323       **/1324      setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1325      /**1326       * Add or change collection properties.1327       * 1328       * # Permissions1329       * 1330       * * Collection owner1331       * * Collection admin1332       * 1333       * # Arguments1334       * 1335       * * `collection_id`: ID of the modified collection.1336       * * `properties`: Vector of key-value pairs stored as the collection's metadata.1337       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1338       **/1339      setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1340      /**1341       * Set (invite) a new collection sponsor.1342       * 1343       * If successful, confirmation from the sponsor-to-be will be pending.1344       * 1345       * # Permissions1346       * 1347       * * Collection owner1348       * * Collection admin1349       * 1350       * # Arguments1351       * 1352       * * `collection_id`: ID of the modified collection.1353       * * `new_sponsor`: ID of the account of the sponsor-to-be.1354       **/1355      setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1356      /**1357       * Add or change token properties according to collection's permissions.1358       * Currently properties only work with NFTs.1359       * 1360       * # Permissions1361       * 1362       * * Depends on collection's token property permissions and specified property mutability:1363       * * Collection owner1364       * * Collection admin1365       * * Token owner1366       * 1367       * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1368       * 1369       * # Arguments1370       * 1371       * * `collection_id: ID of the collection to which the token belongs.1372       * * `token_id`: ID of the modified token.1373       * * `properties`: Vector of key-value pairs stored as the token's metadata.1374       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1375       **/1376      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>]>;1377      /**1378       * Add or change token property permissions of a collection.1379       * 1380       * Without a permission for a particular key, a property with that key1381       * cannot be created in a token.1382       * 1383       * # Permissions1384       * 1385       * * Collection owner1386       * * Collection admin1387       * 1388       * # Arguments1389       * 1390       * * `collection_id`: ID of the modified collection.1391       * * `property_permissions`: Vector of permissions for property keys.1392       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1393       **/1394      setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1395      /**1396       * Completely allow or disallow transfers for a particular collection.1397       * 1398       * # Permissions1399       * 1400       * * Collection owner1401       * 1402       * # Arguments1403       * 1404       * * `collection_id`: ID of the collection.1405       * * `value`: New value of the flag, are transfers allowed?1406       **/1407      setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1408      /**1409       * Change ownership of the token.1410       * 1411       * # Permissions1412       * 1413       * * Collection owner1414       * * Collection admin1415       * * Current token owner1416       * 1417       * # Arguments1418       * 1419       * * `recipient`: Address of token recipient.1420       * * `collection_id`: ID of the collection the item belongs to.1421       * * `item_id`: ID of the item.1422       * * Non-Fungible Mode: Required.1423       * * Fungible Mode: Ignored.1424       * * Re-Fungible Mode: Required.1425       * 1426       * * `value`: Amount to transfer.1427       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1428       * * Fungible Mode: The desired number of pieces to transfer.1429       * * Re-Fungible Mode: The desired number of pieces to transfer.1430       **/1431      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]>;1432      /**1433       * Change ownership of an item on behalf of the owner as a non-owner account.1434       * 1435       * See the [`approve`][`Pallet::approve`] method for additional information.1436       * 1437       * After this method executes, one approval is removed from the total so that1438       * the approved address will not be able to transfer this item again from this owner.1439       * 1440       * # Permissions1441       * 1442       * * Collection owner1443       * * Collection admin1444       * * Current item owner1445       * * Address approved by current item owner1446       * 1447       * # Arguments1448       * 1449       * * `from`: Address that currently owns the token.1450       * * `recipient`: Address of the new token-owner-to-be.1451       * * `collection_id`: ID of the collection the item.1452       * * `item_id`: ID of the item to be transferred.1453       * * `value`: Amount to transfer.1454       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1455       * * Fungible Mode: The desired number of pieces to transfer.1456       * * Re-Fungible Mode: The desired number of pieces to transfer.1457       **/1458      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]>;1459      /**1460       * Generic tx1461       **/1462      [key: string]: SubmittableExtrinsicFunction<ApiType>;1463    };1464    vesting: {1465      claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1466      claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1467      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>]>;1468      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]>;1469      /**1470       * Generic tx1471       **/1472      [key: string]: SubmittableExtrinsicFunction<ApiType>;1473    };1474    xcmpQueue: {1475      /**1476       * Resumes all XCM executions for the XCMP queue.1477       * 1478       * Note that this function doesn't change the status of the in/out bound channels.1479       * 1480       * - `origin`: Must pass `ControllerOrigin`.1481       **/1482      resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1483      /**1484       * Services a single overweight XCM.1485       * 1486       * - `origin`: Must pass `ExecuteOverweightOrigin`.1487       * - `index`: The index of the overweight XCM to service1488       * - `weight_limit`: The amount of weight that XCM execution may take.1489       * 1490       * Errors:1491       * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1492       * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1493       * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1494       * 1495       * Events:1496       * - `OverweightServiced`: On success.1497       **/1498      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1499      /**1500       * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1501       * 1502       * - `origin`: Must pass `ControllerOrigin`.1503       **/1504      suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1505      /**1506       * Overwrites the number of pages of messages which must be in the queue after which we drop any further1507       * messages from the channel.1508       * 1509       * - `origin`: Must pass `Root`.1510       * - `new`: Desired value for `QueueConfigData.drop_threshold`1511       **/1512      updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1513      /**1514       * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1515       * message sending may recommence after it has been suspended.1516       * 1517       * - `origin`: Must pass `Root`.1518       * - `new`: Desired value for `QueueConfigData.resume_threshold`1519       **/1520      updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1521      /**1522       * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1523       * suspend their sending.1524       * 1525       * - `origin`: Must pass `Root`.1526       * - `new`: Desired value for `QueueConfigData.suspend_value`1527       **/1528      updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1529      /**1530       * Overwrites the amount of remaining weight under which we stop processing messages.1531       * 1532       * - `origin`: Must pass `Root`.1533       * - `new`: Desired value for `QueueConfigData.threshold_weight`1534       **/1535      updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1536      /**1537       * Overwrites the speed to which the available weight approaches the maximum weight.1538       * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1539       * 1540       * - `origin`: Must pass `Root`.1541       * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1542       **/1543      updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1544      /**1545       * Overwrite the maximum amount of weight any individual message may consume.1546       * Messages above this weight go into the overweight queue and may only be serviced explicitly.1547       * 1548       * - `origin`: Must pass `Root`.1549       * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1550       **/1551      updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1552      /**1553       * Generic tx1554       **/1555      [key: string]: SubmittableExtrinsicFunction<ApiType>;1556    };1557  } // AugmentedSubmittables1558} // declare module