git.delta.rocks / unique-network / refs/commits / ff1beacfa78e

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    appPromotion: {21      payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;22      setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;23      sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;24      sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;25      stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;26      stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;27      stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;28      unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;29      /**30       * Generic tx31       **/32      [key: string]: SubmittableExtrinsicFunction<ApiType>;33    };34    balances: {35      /**36       * Exactly as `transfer`, except the origin must be root and the source account may be37       * specified.38       * # <weight>39       * - Same as transfer, but additional read and write because the source account is not40       * assumed to be in the overlay.41       * # </weight>42       **/43      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>]>;44      /**45       * Unreserve some balance from a user by force.46       * 47       * Can only be called by ROOT.48       **/49      forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;50      /**51       * Set the balances of a given account.52       * 53       * This will alter `FreeBalance` and `ReservedBalance` in storage. it will54       * also alter the total issuance of the system (`TotalIssuance`) appropriately.55       * If the new free or reserved balance is below the existential deposit,56       * it will reset the account nonce (`frame_system::AccountNonce`).57       * 58       * The dispatch origin for this call is `root`.59       **/60      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>]>;61      /**62       * Transfer some liquid free balance to another account.63       * 64       * `transfer` will set the `FreeBalance` of the sender and receiver.65       * If the sender's account is below the existential deposit as a result66       * of the transfer, the account will be reaped.67       * 68       * The dispatch origin for this call must be `Signed` by the transactor.69       * 70       * # <weight>71       * - Dependent on arguments but not critical, given proper implementations for input config72       * types. See related functions below.73       * - It contains a limited number of reads and writes internally and no complex74       * computation.75       * 76       * Related functions:77       * 78       * - `ensure_can_withdraw` is always called internally but has a bounded complexity.79       * - Transferring balances to accounts that did not exist before will cause80       * `T::OnNewAccount::on_new_account` to be called.81       * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.82       * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check83       * that the transfer will not kill the origin account.84       * ---------------------------------85       * - Origin account is already in memory, so no DB operations for them.86       * # </weight>87       **/88      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>]>;89      /**90       * Transfer the entire transferable balance from the caller account.91       * 92       * NOTE: This function only attempts to transfer _transferable_ balances. This means that93       * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be94       * transferred by this function. To ensure that this function results in a killed account,95       * you might need to prepare the account by removing any reference counters, storage96       * deposits, etc...97       * 98       * The dispatch origin of this call must be Signed.99       * 100       * - `dest`: The recipient of the transfer.101       * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all102       * of the funds the account has, causing the sender account to be killed (false), or103       * transfer everything except at least the existential deposit, which will guarantee to104       * keep the sender account alive (true). # <weight>105       * - O(1). Just like transfer, but reading the user's transferable balance first.106       * #</weight>107       **/108      transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;109      /**110       * Same as the [`transfer`] call, but with a check that the transfer will not kill the111       * origin account.112       * 113       * 99% of the time you want [`transfer`] instead.114       * 115       * [`transfer`]: struct.Pallet.html#method.transfer116       **/117      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>]>;118      /**119       * Generic tx120       **/121      [key: string]: SubmittableExtrinsicFunction<ApiType>;122    };123    charging: {124      /**125       * Generic tx126       **/127      [key: string]: SubmittableExtrinsicFunction<ApiType>;128    };129    configuration: {130      setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;131      setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;132      /**133       * Generic tx134       **/135      [key: string]: SubmittableExtrinsicFunction<ApiType>;136    };137    cumulusXcm: {138      /**139       * Generic tx140       **/141      [key: string]: SubmittableExtrinsicFunction<ApiType>;142    };143    dmpQueue: {144      /**145       * Service a single overweight message.146       * 147       * - `origin`: Must pass `ExecuteOverweightOrigin`.148       * - `index`: The index of the overweight message to service.149       * - `weight_limit`: The amount of weight that message execution may take.150       * 151       * Errors:152       * - `Unknown`: Message of `index` is unknown.153       * - `OverLimit`: Message execution may use greater than `weight_limit`.154       * 155       * Events:156       * - `OverweightServiced`: On success.157       **/158      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;159      /**160       * Generic tx161       **/162      [key: string]: SubmittableExtrinsicFunction<ApiType>;163    };164    ethereum: {165      /**166       * Transact an Ethereum transaction.167       **/168      transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;169      /**170       * Generic tx171       **/172      [key: string]: SubmittableExtrinsicFunction<ApiType>;173    };174    evm: {175      /**176       * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.177       **/178      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>]>>]>;179      /**180       * Issue an EVM create operation. This is similar to a contract creation transaction in181       * Ethereum.182       **/183      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>]>>]>;184      /**185       * Issue an EVM create2 operation.186       **/187      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>]>>]>;188      /**189       * Withdraw balance from EVM into currency/balances pallet.190       **/191      withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;192      /**193       * Generic tx194       **/195      [key: string]: SubmittableExtrinsicFunction<ApiType>;196    };197    evmMigration: {198      /**199       * Start contract migration, inserts contract stub at target address,200       * and marks account as pending, allowing to insert storage201       **/202      begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;203      /**204       * Finish contract migration, allows it to be called.205       * It is not possible to alter contract storage via [`Self::set_data`]206       * after this call.207       **/208      finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;209      /**210       * Insert items into contract storage, this method can be called211       * multiple times212       **/213      setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;214      /**215       * Generic tx216       **/217      [key: string]: SubmittableExtrinsicFunction<ApiType>;218    };219    inflation: {220      /**221       * This method sets the inflation start date. Can be only called once.222       * Inflation start block can be backdated and will catch up. The method will create Treasury223       * account if it does not exist and perform the first inflation deposit.224       * 225       * # Permissions226       * 227       * * Root228       * 229       * # Arguments230       * 231       * * inflation_start_relay_block: The relay chain block at which inflation should start232       **/233      startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;234      /**235       * Generic tx236       **/237      [key: string]: SubmittableExtrinsicFunction<ApiType>;238    };239    parachainSystem: {240      authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;241      enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;242      /**243       * Set the current validation data.244       * 245       * This should be invoked exactly once per block. It will panic at the finalization246       * phase if the call was not invoked.247       * 248       * The dispatch origin for this call must be `Inherent`249       * 250       * As a side effect, this function upgrades the current validation function251       * if the appropriate time has come.252       **/253      setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;254      sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;255      /**256       * Generic tx257       **/258      [key: string]: SubmittableExtrinsicFunction<ApiType>;259    };260    polkadotXcm: {261      /**262       * Execute an XCM message from a local, signed, origin.263       * 264       * An event is deposited indicating whether `msg` could be executed completely or only265       * partially.266       * 267       * No more than `max_weight` will be used in its attempted execution. If this is less than the268       * maximum amount of weight that the message could take to be executed, then no execution269       * attempt will be made.270       * 271       * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully272       * to completion; only that *some* of it was executed.273       **/274      execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;275      /**276       * Set a safe XCM version (the version that XCM should be encoded with if the most recent277       * version a destination can accept is unknown).278       * 279       * - `origin`: Must be Root.280       * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.281       **/282      forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;283      /**284       * Ask a location to notify us regarding their XCM version and any changes to it.285       * 286       * - `origin`: Must be Root.287       * - `location`: The location to which we should subscribe for XCM version notifications.288       **/289      forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;290      /**291       * Require that a particular destination should no longer notify us regarding any XCM292       * version changes.293       * 294       * - `origin`: Must be Root.295       * - `location`: The location to which we are currently subscribed for XCM version296       * notifications which we no longer desire.297       **/298      forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;299      /**300       * Extoll that a particular destination can be communicated with through a particular301       * version of XCM.302       * 303       * - `origin`: Must be Root.304       * - `location`: The destination that is being described.305       * - `xcm_version`: The latest version of XCM that `location` supports.306       **/307      forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;308      /**309       * Transfer some assets from the local chain to the sovereign account of a destination310       * chain and forward a notification XCM.311       * 312       * Fee payment on the destination side is made from the asset in the `assets` vector of313       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight314       * is needed than `weight_limit`, then the operation will fail and the assets send may be315       * at risk.316       * 317       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.318       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send319       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.320       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be321       * an `AccountId32` value.322       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the323       * `dest` side.324       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay325       * fees.326       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.327       **/328      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]>;329      /**330       * Teleport some assets from the local chain to some destination chain.331       * 332       * Fee payment on the destination side is made from the asset in the `assets` vector of333       * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight334       * is needed than `weight_limit`, then the operation will fail and the assets send may be335       * at risk.336       * 337       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.338       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send339       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.340       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be341       * an `AccountId32` value.342       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the343       * `dest` side. May not be empty.344       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay345       * fees.346       * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.347       **/348      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]>;349      /**350       * Transfer some assets from the local chain to the sovereign account of a destination351       * chain and forward a notification XCM.352       * 353       * Fee payment on the destination side is made from the asset in the `assets` vector of354       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,355       * with all fees taken as needed from the asset.356       * 357       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.358       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send359       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.360       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be361       * an `AccountId32` value.362       * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the363       * `dest` side.364       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay365       * fees.366       **/367      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]>;368      send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;369      /**370       * Teleport some assets from the local chain to some destination chain.371       * 372       * Fee payment on the destination side is made from the asset in the `assets` vector of373       * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,374       * with all fees taken as needed from the asset.375       * 376       * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.377       * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send378       * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.379       * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be380       * an `AccountId32` value.381       * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the382       * `dest` side. May not be empty.383       * - `fee_asset_item`: The index into `assets` of the item which should be used to pay384       * fees.385       **/386      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]>;387      /**388       * Generic tx389       **/390      [key: string]: SubmittableExtrinsicFunction<ApiType>;391    };392    rmrkCore: {393      /**394       * Accept an NFT sent from another account to self or an owned NFT.395       * 396       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.397       * 398       * # Permissions:399       * - Token-owner-to-be400       * 401       * # Arguments:402       * - `origin`: sender of the transaction403       * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.404       * - `rmrk_nft_id`: ID of the NFT to be accepted.405       * - `new_owner`: Either the sender's account ID or a sender-owned NFT,406       * whichever the accepted NFT was sent to.407       **/408      acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;409      /**410       * Accept the addition of a newly created pending resource to an existing NFT.411       * 412       * This transaction is needed when a resource is created and assigned to an NFT413       * by a non-owner, i.e. the collection issuer, with one of the414       * [`add_...` transactions](Pallet::add_basic_resource).415       * 416       * # Permissions:417       * - Token owner418       * 419       * # Arguments:420       * - `origin`: sender of the transaction421       * - `rmrk_collection_id`: RMRK collection ID of the NFT.422       * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.423       * - `resource_id`: ID of the newly created pending resource.424       * accept the addition of a new resource to an existing NFT425       **/426      acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;427      /**428       * Accept the removal of a removal-pending resource from an NFT.429       * 430       * This transaction is needed when a non-owner, i.e. the collection issuer,431       * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.432       * 433       * # Permissions:434       * - Token owner435       * 436       * # Arguments:437       * - `origin`: sender of the transaction438       * - `rmrk_collection_id`: RMRK collection ID of the NFT.439       * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.440       * - `resource_id`: ID of the removal-pending resource.441       **/442      acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;443      /**444       * Create and set/propose a basic resource for an NFT.445       * 446       * A basic resource is the simplest, lacking a Base and anything that comes with it.447       * See RMRK docs for more information and examples.448       * 449       * # Permissions:450       * - Collection issuer - if not the token owner, adding the resource will warrant451       * the owner's [acceptance](Pallet::accept_resource).452       * 453       * # Arguments:454       * - `origin`: sender of the transaction455       * - `rmrk_collection_id`: RMRK collection ID of the NFT.456       * - `nft_id`: ID of the NFT to assign a resource to.457       * - `resource`: Data of the resource to be created.458       **/459      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]>;460      /**461       * Create and set/propose a composable resource for an NFT.462       * 463       * A composable resource links to a Base and has a subset of its Parts it is composed of.464       * See RMRK docs for more information and examples.465       * 466       * # Permissions:467       * - Collection issuer - if not the token owner, adding the resource will warrant468       * the owner's [acceptance](Pallet::accept_resource).469       * 470       * # Arguments:471       * - `origin`: sender of the transaction472       * - `rmrk_collection_id`: RMRK collection ID of the NFT.473       * - `nft_id`: ID of the NFT to assign a resource to.474       * - `resource`: Data of the resource to be created.475       **/476      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]>;477      /**478       * Create and set/propose a slot resource for an NFT.479       * 480       * A slot resource links to a Base and a slot ID in it which it can fit into.481       * See RMRK docs for more information and examples.482       * 483       * # Permissions:484       * - Collection issuer - if not the token owner, adding the resource will warrant485       * the owner's [acceptance](Pallet::accept_resource).486       * 487       * # Arguments:488       * - `origin`: sender of the transaction489       * - `rmrk_collection_id`: RMRK collection ID of the NFT.490       * - `nft_id`: ID of the NFT to assign a resource to.491       * - `resource`: Data of the resource to be created.492       **/493      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]>;494      /**495       * Burn an NFT, destroying it and its nested tokens up to the specified limit.496       * If the burning budget is exceeded, the transaction is reverted.497       * 498       * This is the way to burn a nested token as well.499       * 500       * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).501       * 502       * # Permissions:503       * * Token owner504       * 505       * # Arguments:506       * - `origin`: sender of the transaction507       * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.508       * - `nft_id`: ID of the NFT to be destroyed.509       * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction510       * is reverted if there are more tokens to burn in the nesting tree than this number.511       * This is primarily a mechanism of transaction weight control.512       **/513      burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;514      /**515       * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).516       * 517       * # Permissions:518       * * Collection issuer519       * 520       * # Arguments:521       * - `origin`: sender of the transaction522       * - `collection_id`: RMRK collection ID to change the issuer of.523       * - `new_issuer`: Collection's new issuer.524       **/525      changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;526      /**527       * Create a new collection of NFTs.528       * 529       * # Permissions:530       * * Anyone - will be assigned as the issuer of the collection.531       * 532       * # Arguments:533       * - `origin`: sender of the transaction534       * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.535       * - `max`: Optional maximum number of tokens.536       * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.537       * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.538       **/539      createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;540      /**541       * Destroy a collection.542       * 543       * Only empty collections can be destroyed. If it has any tokens, they must be burned first.544       * 545       * # Permissions:546       * * Collection issuer547       * 548       * # Arguments:549       * - `origin`: sender of the transaction550       * - `collection_id`: RMRK ID of the collection to destroy.551       **/552      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;553      /**554       * "Lock" the collection and prevent new token creation. Cannot be undone.555       * 556       * # Permissions:557       * * Collection issuer558       * 559       * # Arguments:560       * - `origin`: sender of the transaction561       * - `collection_id`: RMRK ID of the collection to lock.562       **/563      lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;564      /**565       * Mint an NFT in a specified collection.566       * 567       * # Permissions:568       * * Collection issuer569       * 570       * # Arguments:571       * - `origin`: sender of the transaction572       * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).573       * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.574       * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.575       * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.576       * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.577       * - `transferable`: Can this NFT be transferred? Cannot be changed.578       * - `resources`: Resource data to be added to the NFT immediately after minting.579       **/580      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>>]>;581      /**582       * Reject an NFT sent from another account to self or owned NFT.583       * The NFT in question will not be sent back and burnt instead.584       * 585       * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.586       * 587       * # Permissions:588       * - Token-owner-to-be-not589       * 590       * # Arguments:591       * - `origin`: sender of the transaction592       * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.593       * - `rmrk_nft_id`: ID of the NFT to be rejected.594       **/595      rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;596      /**597       * Remove and erase a resource from an NFT.598       * 599       * If the sender does not own the NFT, then it will be pending confirmation,600       * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.601       * 602       * # Permissions603       * - Collection issuer604       * 605       * # Arguments606       * - `origin`: sender of the transaction607       * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.608       * - `nft_id`: ID of the NFT with a resource to be removed.609       * - `resource_id`: ID of the resource to be removed.610       **/611      removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;612      /**613       * Transfer an NFT from an account/NFT A to another account/NFT B.614       * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].615       * 616       * If the target owner is an NFT owned by another account, then the NFT will enter617       * the pending state and will have to be accepted by the other account.618       * 619       * # Permissions:620       * - Token owner621       * 622       * # Arguments:623       * - `origin`: sender of the transaction624       * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.625       * - `rmrk_nft_id`: ID of the NFT to be transferred.626       * - `new_owner`: New owner of the nft which can be either an account or a NFT.627       **/628      send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;629      /**630       * Set a different order of resource priorities for an NFT. Priorities can be used,631       * for example, for order of rendering.632       * 633       * Note that the priorities are not updated automatically, and are an empty vector634       * by default. There is no pre-set definition for the order to be particular,635       * it can be interpreted arbitrarily use-case by use-case.636       * 637       * # Permissions:638       * - Token owner639       * 640       * # Arguments:641       * - `origin`: sender of the transaction642       * - `rmrk_collection_id`: RMRK collection ID of the NFT.643       * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.644       * - `priorities`: Ordered vector of resource IDs.645       **/646      setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;647      /**648       * Add or edit a custom user property, a key-value pair, describing the metadata649       * of a token or a collection, on either one of these.650       * 651       * Note that in this proxy implementation many details regarding RMRK are stored652       * as scoped properties prefixed with "rmrk:", normally inaccessible653       * to external transactions and RPCs.654       * 655       * # Permissions:656       * - Collection issuer - in case of collection property657       * - Token owner - in case of NFT property658       * 659       * # Arguments:660       * - `origin`: sender of the transaction661       * - `rmrk_collection_id`: RMRK collection ID.662       * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.663       * - `key`: Key of the custom property to be referenced by.664       * - `value`: Value of the custom property to be stored.665       **/666      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]>;667      /**668       * Generic tx669       **/670      [key: string]: SubmittableExtrinsicFunction<ApiType>;671    };672    rmrkEquip: {673      /**674       * Create a new Base.675       * 676       * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)677       * 678       * # Permissions679       * - Anyone - will be assigned as the issuer of the Base.680       * 681       * # Arguments:682       * - `origin`: Caller, will be assigned as the issuer of the Base683       * - `base_type`: Arbitrary media type, e.g. "svg".684       * - `symbol`: Arbitrary client-chosen symbol.685       * - `parts`: Array of Fixed and Slot Parts composing the Base,686       * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).687       **/688      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>]>;689      /**690       * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.691       * 692       * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).693       * 694       * # Permissions:695       * - Base issuer696       * 697       * # Arguments:698       * - `origin`: sender of the transaction699       * - `base_id`: Base containing the Slot Part to be updated.700       * - `slot_id`: Slot Part whose Equippable List is being updated .701       * - `equippables`: List of equippables that will override the current Equippables list.702       **/703      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]>;704      /**705       * Add a Theme to a Base.706       * A Theme named "default" is required prior to adding other Themes.707       * 708       * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).709       * 710       * # Permissions:711       * - Base issuer712       * 713       * # Arguments:714       * - `origin`: sender of the transaction715       * - `base_id`: Base ID containing the Theme to be updated.716       * - `theme`: Theme to add to the Base.  A Theme has a name and properties, which are an717       * array of [key, value, inherit].718       * - `key`: Arbitrary BoundedString, defined by client.719       * - `value`: Arbitrary BoundedString, defined by client.720       * - `inherit`: Optional bool.721       **/722      themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;723      /**724       * Generic tx725       **/726      [key: string]: SubmittableExtrinsicFunction<ApiType>;727    };728    scheduler: {729      /**730       * Cancel a named scheduled task.731       **/732      cancelNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed]>;733      /**734       * Schedule a named task.735       **/736      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]>;737      /**738       * Schedule a named task after a delay.739       * 740       * # <weight>741       * Same as [`schedule_named`](Self::schedule_named).742       * # </weight>743       **/744      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]>;745      /**746       * Generic tx747       **/748      [key: string]: SubmittableExtrinsicFunction<ApiType>;749    };750    structure: {751      /**752       * Generic tx753       **/754      [key: string]: SubmittableExtrinsicFunction<ApiType>;755    };756    sudo: {757      /**758       * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo759       * key.760       * 761       * The dispatch origin for this call must be _Signed_.762       * 763       * # <weight>764       * - O(1).765       * - Limited storage reads.766       * - One DB change.767       * # </weight>768       **/769      setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;770      /**771       * Authenticates the sudo key and dispatches a function call with `Root` origin.772       * 773       * The dispatch origin for this call must be _Signed_.774       * 775       * # <weight>776       * - O(1).777       * - Limited storage reads.778       * - One DB write (event).779       * - Weight of derivative `call` execution + 10,000.780       * # </weight>781       **/782      sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;783      /**784       * Authenticates the sudo key and dispatches a function call with `Signed` origin from785       * a given account.786       * 787       * The dispatch origin for this call must be _Signed_.788       * 789       * # <weight>790       * - O(1).791       * - Limited storage reads.792       * - One DB write (event).793       * - Weight of derivative `call` execution + 10,000.794       * # </weight>795       **/796      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]>;797      /**798       * Authenticates the sudo key and dispatches a function call with `Root` origin.799       * This function does not check the weight of the call, and instead allows the800       * Sudo user to specify the weight of the call.801       * 802       * The dispatch origin for this call must be _Signed_.803       * 804       * # <weight>805       * - O(1).806       * - The weight of this call is defined by the caller.807       * # </weight>808       **/809      sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, u64]>;810      /**811       * Generic tx812       **/813      [key: string]: SubmittableExtrinsicFunction<ApiType>;814    };815    system: {816      /**817       * A dispatch that will fill the block weight up to the given ratio.818       **/819      fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;820      /**821       * Kill all storage items with a key that starts with the given prefix.822       * 823       * **NOTE:** We rely on the Root origin to provide us the number of subkeys under824       * the prefix we are removing to accurately calculate the weight of this function.825       **/826      killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;827      /**828       * Kill some items from storage.829       **/830      killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;831      /**832       * Make some on-chain remark.833       * 834       * # <weight>835       * - `O(1)`836       * # </weight>837       **/838      remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;839      /**840       * Make some on-chain remark and emit event.841       **/842      remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;843      /**844       * Set the new runtime code.845       * 846       * # <weight>847       * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`848       * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is849       * expensive).850       * - 1 storage write (codec `O(C)`).851       * - 1 digest item.852       * - 1 event.853       * The weight of this function is dependent on the runtime, but generally this is very854       * expensive. We will treat this as a full block.855       * # </weight>856       **/857      setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;858      /**859       * Set the new runtime code without doing any checks of the given `code`.860       * 861       * # <weight>862       * - `O(C)` where `C` length of `code`863       * - 1 storage write (codec `O(C)`).864       * - 1 digest item.865       * - 1 event.866       * The weight of this function is dependent on the runtime. We will treat this as a full867       * block. # </weight>868       **/869      setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;870      /**871       * Set the number of pages in the WebAssembly environment's heap.872       **/873      setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;874      /**875       * Set some items of storage.876       **/877      setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;878      /**879       * Generic tx880       **/881      [key: string]: SubmittableExtrinsicFunction<ApiType>;882    };883    timestamp: {884      /**885       * Set the current time.886       * 887       * This call should be invoked exactly once per block. It will panic at the finalization888       * phase, if this call hasn't been invoked by that time.889       * 890       * The timestamp should be greater than the previous one by the amount specified by891       * `MinimumPeriod`.892       * 893       * The dispatch origin for this call must be `Inherent`.894       * 895       * # <weight>896       * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)897       * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in898       * `on_finalize`)899       * - 1 event handler `on_timestamp_set`. Must be `O(1)`.900       * # </weight>901       **/902      set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;903      /**904       * Generic tx905       **/906      [key: string]: SubmittableExtrinsicFunction<ApiType>;907    };908    treasury: {909      /**910       * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary911       * and the original deposit will be returned.912       * 913       * May only be called from `T::ApproveOrigin`.914       * 915       * # <weight>916       * - Complexity: O(1).917       * - DbReads: `Proposals`, `Approvals`918       * - DbWrite: `Approvals`919       * # </weight>920       **/921      approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;922      /**923       * Put forward a suggestion for spending. A deposit proportional to the value924       * is reserved and slashed if the proposal is rejected. It is returned once the925       * proposal is awarded.926       * 927       * # <weight>928       * - Complexity: O(1)929       * - DbReads: `ProposalCount`, `origin account`930       * - DbWrites: `ProposalCount`, `Proposals`, `origin account`931       * # </weight>932       **/933      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]>;934      /**935       * Reject a proposed spend. The original deposit will be slashed.936       * 937       * May only be called from `T::RejectOrigin`.938       * 939       * # <weight>940       * - Complexity: O(1)941       * - DbReads: `Proposals`, `rejected proposer account`942       * - DbWrites: `Proposals`, `rejected proposer account`943       * # </weight>944       **/945      rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;946      /**947       * Force a previously approved proposal to be removed from the approval queue.948       * The original deposit will no longer be returned.949       * 950       * May only be called from `T::RejectOrigin`.951       * - `proposal_id`: The index of a proposal952       * 953       * # <weight>954       * - Complexity: O(A) where `A` is the number of approvals955       * - Db reads and writes: `Approvals`956       * # </weight>957       * 958       * Errors:959       * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,960       * i.e., the proposal has not been approved. This could also mean the proposal does not961       * exist altogether, thus there is no way it would have been approved in the first place.962       **/963      removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;964      /**965       * Propose and approve a spend of treasury funds.966       * 967       * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.968       * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.969       * - `beneficiary`: The destination account for the transfer.970       * 971       * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the972       * beneficiary.973       **/974      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]>;975      /**976       * Generic tx977       **/978      [key: string]: SubmittableExtrinsicFunction<ApiType>;979    };980    unique: {981      /**982       * Add an admin to a collection.983       * 984       * NFT Collection can be controlled by multiple admin addresses985       * (some which can also be servers, for example). Admins can issue986       * and burn NFTs, as well as add and remove other admins,987       * but cannot change NFT or Collection ownership.988       * 989       * # Permissions990       * 991       * * Collection owner992       * * Collection admin993       * 994       * # Arguments995       * 996       * * `collection_id`: ID of the Collection to add an admin for.997       * * `new_admin`: Address of new admin to add.998       **/999      addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1000      /**1001       * Add an address to allow list.1002       * 1003       * # Permissions1004       * 1005       * * Collection owner1006       * * Collection admin1007       * 1008       * # Arguments1009       * 1010       * * `collection_id`: ID of the modified collection.1011       * * `address`: ID of the address to be added to the allowlist.1012       **/1013      addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1014      /**1015       * Allow a non-permissioned address to transfer or burn an item.1016       * 1017       * # Permissions1018       * 1019       * * Collection owner1020       * * Collection admin1021       * * Current item owner1022       * 1023       * # Arguments1024       * 1025       * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1026       * * `collection_id`: ID of the collection the item belongs to.1027       * * `item_id`: ID of the item transactions on which are now approved.1028       * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1029       * Set to 0 to revoke the approval.1030       **/1031      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]>;1032      /**1033       * Destroy a token on behalf of the owner as a non-owner account.1034       * 1035       * See also: [`approve`][`Pallet::approve`].1036       * 1037       * After this method executes, one approval is removed from the total so that1038       * the approved address will not be able to transfer this item again from this owner.1039       * 1040       * # Permissions1041       * 1042       * * Collection owner1043       * * Collection admin1044       * * Current token owner1045       * * Address approved by current item owner1046       * 1047       * # Arguments1048       * 1049       * * `from`: The owner of the burning item.1050       * * `collection_id`: ID of the collection to which the item belongs.1051       * * `item_id`: ID of item to burn.1052       * * `value`: Number of pieces to burn.1053       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1054       * * Fungible Mode: The desired number of pieces to burn.1055       * * Re-Fungible Mode: The desired number of pieces to burn.1056       **/1057      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]>;1058      /**1059       * Destroy an item.1060       * 1061       * # Permissions1062       * 1063       * * Collection owner1064       * * Collection admin1065       * * Current item owner1066       * 1067       * # Arguments1068       * 1069       * * `collection_id`: ID of the collection to which the item belongs.1070       * * `item_id`: ID of item to burn.1071       * * `value`: Number of pieces of the item to destroy.1072       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1073       * * Fungible Mode: The desired number of pieces to burn.1074       * * Re-Fungible Mode: The desired number of pieces to burn.1075       **/1076      burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1077      /**1078       * Change the owner of the collection.1079       * 1080       * # Permissions1081       * 1082       * * Collection owner1083       * 1084       * # Arguments1085       * 1086       * * `collection_id`: ID of the modified collection.1087       * * `new_owner`: ID of the account that will become the owner.1088       **/1089      changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1090      /**1091       * Confirm own sponsorship of a collection, becoming the sponsor.1092       * 1093       * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1094       * Sponsor can pay the fees of a transaction instead of the sender,1095       * but only within specified limits.1096       * 1097       * # Permissions1098       * 1099       * * Sponsor-to-be1100       * 1101       * # Arguments1102       * 1103       * * `collection_id`: ID of the collection with the pending sponsor.1104       **/1105      confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1106      /**1107       * Create a collection of tokens.1108       * 1109       * Each Token may have multiple properties encoded as an array of bytes1110       * of certain length. The initial owner of the collection is set1111       * to the address that signed the transaction and can be changed later.1112       * 1113       * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1114       * 1115       * # Permissions1116       * 1117       * * Anyone - becomes the owner of the new collection.1118       * 1119       * # Arguments1120       * 1121       * * `collection_name`: Wide-character string with collection name1122       * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1123       * * `collection_description`: Wide-character string with collection description1124       * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1125       * * `token_prefix`: Byte string containing the token prefix to mark a collection1126       * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1127       * * `mode`: Type of items stored in the collection and type dependent data.1128       **/1129      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]>;1130      /**1131       * Create a collection with explicit parameters.1132       * 1133       * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1134       * 1135       * # Permissions1136       * 1137       * * Anyone - becomes the owner of the new collection.1138       * 1139       * # Arguments1140       * 1141       * * `data`: Explicit data of a collection used for its creation.1142       **/1143      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]>;1144      /**1145       * Mint an item within a collection.1146       * 1147       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1148       * 1149       * # Permissions1150       * 1151       * * Collection owner1152       * * Collection admin1153       * * Anyone if1154       * * Allow List is enabled, and1155       * * Address is added to allow list, and1156       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1157       * 1158       * # Arguments1159       * 1160       * * `collection_id`: ID of the collection to which an item would belong.1161       * * `owner`: Address of the initial owner of the item.1162       * * `data`: Token data describing the item to store on chain.1163       **/1164      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]>;1165      /**1166       * Create multiple items within a collection.1167       * 1168       * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1169       * 1170       * # Permissions1171       * 1172       * * Collection owner1173       * * Collection admin1174       * * Anyone if1175       * * Allow List is enabled, and1176       * * Address is added to the allow list, and1177       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1178       * 1179       * # Arguments1180       * 1181       * * `collection_id`: ID of the collection to which the tokens would belong.1182       * * `owner`: Address of the initial owner of the tokens.1183       * * `items_data`: Vector of data describing each item to be created.1184       **/1185      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>]>;1186      /**1187       * Create multiple items within a collection with explicitly specified initial parameters.1188       * 1189       * # Permissions1190       * 1191       * * Collection owner1192       * * Collection admin1193       * * Anyone if1194       * * Allow List is enabled, and1195       * * Address is added to allow list, and1196       * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1197       * 1198       * # Arguments1199       * 1200       * * `collection_id`: ID of the collection to which the tokens would belong.1201       * * `data`: Explicit item creation data.1202       **/1203      createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1204      /**1205       * Delete specified collection properties.1206       * 1207       * # Permissions1208       * 1209       * * Collection Owner1210       * * Collection Admin1211       * 1212       * # Arguments1213       * 1214       * * `collection_id`: ID of the modified collection.1215       * * `property_keys`: Vector of keys of the properties to be deleted.1216       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1217       **/1218      deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1219      /**1220       * Delete specified token properties. Currently properties only work with NFTs.1221       * 1222       * # Permissions1223       * 1224       * * Depends on collection's token property permissions and specified property mutability:1225       * * Collection owner1226       * * Collection admin1227       * * Token owner1228       * 1229       * # Arguments1230       * 1231       * * `collection_id`: ID of the collection to which the token belongs.1232       * * `token_id`: ID of the modified token.1233       * * `property_keys`: Vector of keys of the properties to be deleted.1234       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1235       **/1236      deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1237      /**1238       * Destroy a collection if no tokens exist within.1239       * 1240       * # Permissions1241       * 1242       * * Collection owner1243       * 1244       * # Arguments1245       * 1246       * * `collection_id`: Collection to destroy.1247       **/1248      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1249      /**1250       * Remove admin of a collection.1251       * 1252       * An admin address can remove itself. List of admins may become empty,1253       * in which case only Collection Owner will be able to add an Admin.1254       * 1255       * # Permissions1256       * 1257       * * Collection owner1258       * * Collection admin1259       * 1260       * # Arguments1261       * 1262       * * `collection_id`: ID of the collection to remove the admin for.1263       * * `account_id`: Address of the admin to remove.1264       **/1265      removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1266      /**1267       * Remove a collection's a sponsor, making everyone pay for their own transactions.1268       * 1269       * # Permissions1270       * 1271       * * Collection owner1272       * 1273       * # Arguments1274       * 1275       * * `collection_id`: ID of the collection with the sponsor to remove.1276       **/1277      removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1278      /**1279       * Remove an address from allow list.1280       * 1281       * # Permissions1282       * 1283       * * Collection owner1284       * * Collection admin1285       * 1286       * # Arguments1287       * 1288       * * `collection_id`: ID of the modified collection.1289       * * `address`: ID of the address to be removed from the allowlist.1290       **/1291      removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1292      /**1293       * Re-partition a refungible token, while owning all of its parts/pieces.1294       * 1295       * # Permissions1296       * 1297       * * Token owner (must own every part)1298       * 1299       * # Arguments1300       * 1301       * * `collection_id`: ID of the collection the RFT belongs to.1302       * * `token_id`: ID of the RFT.1303       * * `amount`: New number of parts/pieces into which the token shall be partitioned.1304       **/1305      repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1306      /**1307       * Set specific limits of a collection. Empty, or None fields mean chain default.1308       * 1309       * # Permissions1310       * 1311       * * Collection owner1312       * * Collection admin1313       * 1314       * # Arguments1315       * 1316       * * `collection_id`: ID of the modified collection.1317       * * `new_limit`: New limits of the collection. Fields that are not set (None)1318       * will not overwrite the old ones.1319       **/1320      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]>;1321      /**1322       * Set specific permissions of a collection. Empty, or None fields mean chain default.1323       * 1324       * # Permissions1325       * 1326       * * Collection owner1327       * * Collection admin1328       * 1329       * # Arguments1330       * 1331       * * `collection_id`: ID of the modified collection.1332       * * `new_permission`: New permissions of the collection. Fields that are not set (None)1333       * will not overwrite the old ones.1334       **/1335      setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1336      /**1337       * Add or change collection properties.1338       * 1339       * # Permissions1340       * 1341       * * Collection owner1342       * * Collection admin1343       * 1344       * # Arguments1345       * 1346       * * `collection_id`: ID of the modified collection.1347       * * `properties`: Vector of key-value pairs stored as the collection's metadata.1348       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1349       **/1350      setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1351      /**1352       * Set (invite) a new collection sponsor.1353       * 1354       * If successful, confirmation from the sponsor-to-be will be pending.1355       * 1356       * # Permissions1357       * 1358       * * Collection owner1359       * * Collection admin1360       * 1361       * # Arguments1362       * 1363       * * `collection_id`: ID of the modified collection.1364       * * `new_sponsor`: ID of the account of the sponsor-to-be.1365       **/1366      setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1367      /**1368       * Add or change token properties according to collection's permissions.1369       * Currently properties only work with NFTs.1370       * 1371       * # Permissions1372       * 1373       * * Depends on collection's token property permissions and specified property mutability:1374       * * Collection owner1375       * * Collection admin1376       * * Token owner1377       * 1378       * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1379       * 1380       * # Arguments1381       * 1382       * * `collection_id: ID of the collection to which the token belongs.1383       * * `token_id`: ID of the modified token.1384       * * `properties`: Vector of key-value pairs stored as the token's metadata.1385       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1386       **/1387      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>]>;1388      /**1389       * Add or change token property permissions of a collection.1390       * 1391       * Without a permission for a particular key, a property with that key1392       * cannot be created in a token.1393       * 1394       * # Permissions1395       * 1396       * * Collection owner1397       * * Collection admin1398       * 1399       * # Arguments1400       * 1401       * * `collection_id`: ID of the modified collection.1402       * * `property_permissions`: Vector of permissions for property keys.1403       * Keys support Latin letters, `-`, `_`, and `.` as symbols.1404       **/1405      setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1406      /**1407       * Completely allow or disallow transfers for a particular collection.1408       * 1409       * # Permissions1410       * 1411       * * Collection owner1412       * 1413       * # Arguments1414       * 1415       * * `collection_id`: ID of the collection.1416       * * `value`: New value of the flag, are transfers allowed?1417       **/1418      setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1419      /**1420       * Change ownership of the token.1421       * 1422       * # Permissions1423       * 1424       * * Collection owner1425       * * Collection admin1426       * * Current token owner1427       * 1428       * # Arguments1429       * 1430       * * `recipient`: Address of token recipient.1431       * * `collection_id`: ID of the collection the item belongs to.1432       * * `item_id`: ID of the item.1433       * * Non-Fungible Mode: Required.1434       * * Fungible Mode: Ignored.1435       * * Re-Fungible Mode: Required.1436       * 1437       * * `value`: Amount to transfer.1438       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1439       * * Fungible Mode: The desired number of pieces to transfer.1440       * * Re-Fungible Mode: The desired number of pieces to transfer.1441       **/1442      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]>;1443      /**1444       * Change ownership of an item on behalf of the owner as a non-owner account.1445       * 1446       * See the [`approve`][`Pallet::approve`] method for additional information.1447       * 1448       * After this method executes, one approval is removed from the total so that1449       * the approved address will not be able to transfer this item again from this owner.1450       * 1451       * # Permissions1452       * 1453       * * Collection owner1454       * * Collection admin1455       * * Current item owner1456       * * Address approved by current item owner1457       * 1458       * # Arguments1459       * 1460       * * `from`: Address that currently owns the token.1461       * * `recipient`: Address of the new token-owner-to-be.1462       * * `collection_id`: ID of the collection the item.1463       * * `item_id`: ID of the item to be transferred.1464       * * `value`: Amount to transfer.1465       * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1466       * * Fungible Mode: The desired number of pieces to transfer.1467       * * Re-Fungible Mode: The desired number of pieces to transfer.1468       **/1469      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]>;1470      /**1471       * Generic tx1472       **/1473      [key: string]: SubmittableExtrinsicFunction<ApiType>;1474    };1475    vesting: {1476      claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1477      claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1478      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>]>;1479      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]>;1480      /**1481       * Generic tx1482       **/1483      [key: string]: SubmittableExtrinsicFunction<ApiType>;1484    };1485    xcmpQueue: {1486      /**1487       * Resumes all XCM executions for the XCMP queue.1488       * 1489       * Note that this function doesn't change the status of the in/out bound channels.1490       * 1491       * - `origin`: Must pass `ControllerOrigin`.1492       **/1493      resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1494      /**1495       * Services a single overweight XCM.1496       * 1497       * - `origin`: Must pass `ExecuteOverweightOrigin`.1498       * - `index`: The index of the overweight XCM to service1499       * - `weight_limit`: The amount of weight that XCM execution may take.1500       * 1501       * Errors:1502       * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1503       * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1504       * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1505       * 1506       * Events:1507       * - `OverweightServiced`: On success.1508       **/1509      serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1510      /**1511       * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1512       * 1513       * - `origin`: Must pass `ControllerOrigin`.1514       **/1515      suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1516      /**1517       * Overwrites the number of pages of messages which must be in the queue after which we drop any further1518       * messages from the channel.1519       * 1520       * - `origin`: Must pass `Root`.1521       * - `new`: Desired value for `QueueConfigData.drop_threshold`1522       **/1523      updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1524      /**1525       * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1526       * message sending may recommence after it has been suspended.1527       * 1528       * - `origin`: Must pass `Root`.1529       * - `new`: Desired value for `QueueConfigData.resume_threshold`1530       **/1531      updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1532      /**1533       * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1534       * suspend their sending.1535       * 1536       * - `origin`: Must pass `Root`.1537       * - `new`: Desired value for `QueueConfigData.suspend_value`1538       **/1539      updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1540      /**1541       * Overwrites the amount of remaining weight under which we stop processing messages.1542       * 1543       * - `origin`: Must pass `Root`.1544       * - `new`: Desired value for `QueueConfigData.threshold_weight`1545       **/1546      updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1547      /**1548       * Overwrites the speed to which the available weight approaches the maximum weight.1549       * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1550       * 1551       * - `origin`: Must pass `Root`.1552       * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1553       **/1554      updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1555      /**1556       * Overwrite the maximum amount of weight any individual message may consume.1557       * Messages above this weight go into the overweight queue and may only be serviced explicitly.1558       * 1559       * - `origin`: Must pass `Root`.1560       * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1561       **/1562      updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1563      /**1564       * Generic tx1565       **/1566      [key: string]: SubmittableExtrinsicFunction<ApiType>;1567    };1568  } // AugmentedSubmittables1569} // declare module