packages/definitions/src/interfaces/augment-api-tx.ts
// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
/* eslint-disable */
// import type lookup before we augment - in some environments
// this is required to allow for ambient/previous definitions
import '@polkadot/api-base/types/submittable';
import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types';
import type { BTreeSet, Bytes, Compact, Option, Vec, bool, i64, u128, u16, u32, u64 } from '@polkadot/types-codec';
import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';
import type { AccountId32, Call, H256, MultiAddress, Perbill } from '@polkadot/types/interfaces/runtime';
import type { CumulusPrimitivesParachainInherentParachainInherentData, PalletDomainsInnerValue, PalletPermissionsSpacePermission, PalletPermissionsSpacePermissions, PalletPostsPostExtension, PalletPostsPostUpdate, PalletReactionsReactionKind, PalletRolesRoleUpdate, PalletSpacesSpaceUpdate, PalletVestingVestingInfo, SpRuntimeHeader, SubsocialParachainRuntimeOriginCaller, SubsocialParachainRuntimeProxyType, SubsocialParachainRuntimeSessionKeys, SubsocialSupportContent, SubsocialSupportUser, SubsocialSupportWhoAndWhen, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';
export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;
export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;
export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;
declare module '@polkadot/api-base/types/submittable' {
interface AugmentedSubmittables<ApiType extends ApiTypes> {
accountFollows: {
followAccount: AugmentedSubmittable<(account: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
forceFollowAccount: AugmentedSubmittable<(follower: AccountId32 | string | Uint8Array, following: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, AccountId32]>;
unfollowAccount: AugmentedSubmittable<(account: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;
};
authorship: {
/**
* Provide a set of uncles.
**/
setUncles: AugmentedSubmittable<(newUncles: Vec<SpRuntimeHeader> | (SpRuntimeHeader | { parentHash?: any; number?: any; stateRoot?: any; extrinsicsRoot?: any; digest?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<SpRuntimeHeader>]>;
};
balances: {
/**
* Exactly as `transfer`, except the origin must be root and the source account may be
* specified.
* # <weight>
* - Same as transfer, but additional read and write because the source account is not
* assumed to be in the overlay.
* # </weight>
**/
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>]>;
/**
* Unreserve some balance from a user by force.
*
* Can only be called by ROOT.
**/
forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;
/**
* Set the balances of a given account.
*
* This will alter `FreeBalance` and `ReservedBalance` in storage. it will
* also alter the total issuance of the system (`TotalIssuance`) appropriately.
* If the new free or reserved balance is below the existential deposit,
* it will reset the account nonce (`frame_system::AccountNonce`).
*
* The dispatch origin for this call is `root`.
**/
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>]>;
/**
* Transfer some liquid free balance to another account.
*
* `transfer` will set the `FreeBalance` of the sender and receiver.
* If the sender's account is below the existential deposit as a result
* of the transfer, the account will be reaped.
*
* The dispatch origin for this call must be `Signed` by the transactor.
*
* # <weight>
* - Dependent on arguments but not critical, given proper implementations for input config
* types. See related functions below.
* - It contains a limited number of reads and writes internally and no complex
* computation.
*
* Related functions:
*
* - `ensure_can_withdraw` is always called internally but has a bounded complexity.
* - Transferring balances to accounts that did not exist before will cause
* `T::OnNewAccount::on_new_account` to be called.
* - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.
* - `transfer_keep_alive` works the same way as `transfer`, but has an additional check
* that the transfer will not kill the origin account.
* ---------------------------------
* - Origin account is already in memory, so no DB operations for them.
* # </weight>
**/
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>]>;
/**
* Transfer the entire transferable balance from the caller account.
*
* NOTE: This function only attempts to transfer _transferable_ balances. This means that
* any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be
* transferred by this function. To ensure that this function results in a killed account,
* you might need to prepare the account by removing any reference counters, storage
* deposits, etc...
*
* The dispatch origin of this call must be Signed.
*
* - `dest`: The recipient of the transfer.
* - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all
* of the funds the account has, causing the sender account to be killed (false), or
* transfer everything except at least the existential deposit, which will guarantee to
* keep the sender account alive (true). # <weight>
* - O(1). Just like transfer, but reading the user's transferable balance first.
* #</weight>
**/
transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;
/**
* Same as the [`transfer`] call, but with a check that the transfer will not kill the
* origin account.
*
* 99% of the time you want [`transfer`] instead.
*
* [`transfer`]: struct.Pallet.html#method.transfer
**/
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>]>;
};
collatorSelection: {
/**
* Deregister `origin` as a collator candidate. Note that the collator can only leave on
* session change. The `CandidacyBond` will be unreserved immediately.
*
* This call will fail if the total number of candidates would drop below `MinCandidates`.
*
* This call is not available to `Invulnerable` collators.
**/
leaveIntent: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
/**
* Register this account as a collator candidate. The account must (a) already have
* registered session keys and (b) be able to reserve the `CandidacyBond`.
*
* This call is not available to `Invulnerable` collators.
**/
registerAsCandidate: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
/**
* Set the candidacy bond amount.
**/
setCandidacyBond: AugmentedSubmittable<(bond: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;
/**
* Set the ideal number of collators (not including the invulnerables).
* If lowering this number, then the number of running collators could be higher than this figure.
* Aside from that edge case, there should be no other way to have more collators than the desired number.
**/
setDesiredCandidates: AugmentedSubmittable<(max: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
/**
* Set the list of invulnerable (fixed) collators.
**/
setInvulnerables: AugmentedSubmittable<(updated: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;
};
dmpQueue: {
/**
* Service a single overweight message.
*
* - `origin`: Must pass `ExecuteOverweightOrigin`.
* - `index`: The index of the overweight message to service.
* - `weight_limit`: The amount of weight that message execution may take.
*
* Errors:
* - `Unknown`: Message of `index` is unknown.
* - `OverLimit`: Message execution may use greater than `weight_limit`.
*
* Events:
* - `OverweightServiced`: On success.
**/
serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;
};
domains: {
/**
* Registers a domain ([full_domain]) using root on behalf of a [target] with [content],
* and set the domain to expire in [expires_in] number of blocks.
**/
forceRegisterDomain: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, fullDomain: Bytes | string | Uint8Array, content: SubsocialSupportContent | { None: any } | { Other: any } | { IPFS: any } | string | Uint8Array, expiresIn: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Bytes, SubsocialSupportContent, u32]>;
/**
* Sets the domain inner_value to be one of subsocial account, space, or post.
**/
forceSetInnerValue: AugmentedSubmittable<(domain: Bytes | string | Uint8Array, valueOpt: Option<PalletDomainsInnerValue> | null | Uint8Array | PalletDomainsInnerValue | { Account: any } | { Space: any } | { Post: any } | string) => SubmittableExtrinsic<ApiType>, [Bytes, Option<PalletDomainsInnerValue>]>;
/**
* Registers a domain ([full_domain]) using origin with [content],
* and set the domain to expire in [expires_in] number of blocks.
* [full_domain] is a full domain name including a dot (.) and TLD.
* Example of a [full_domain]: `mytoken.ksm`
**/
registerDomain: AugmentedSubmittable<(fullDomain: Bytes | string | Uint8Array, content: SubsocialSupportContent | { None: any } | { Other: any } | { IPFS: any } | string | Uint8Array, expiresIn: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, SubsocialSupportContent, u32]>;
/**
* Mark set of domains as not reservable by users.
**/
reserveWords: AugmentedSubmittable<(words: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;
/**
* Sets the domain content to be an outside link.
**/
setDomainContent: AugmentedSubmittable<(domain: Bytes | string | Uint8Array, newContent: SubsocialSupportContent | { None: any } | { Other: any } | { IPFS: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, SubsocialSupportContent]>;
/**
* Sets the domain inner_value to be one of Subsocial account, space, or post.
**/
setInnerValue: AugmentedSubmittable<(domain: Bytes | string | Uint8Array, valueOpt: Option<PalletDomainsInnerValue> | null | Uint8Array | PalletDomainsInnerValue | { Account: any } | { Space: any } | { Post: any } | string) => SubmittableExtrinsic<ApiType>, [Bytes, Option<PalletDomainsInnerValue>]>;
/**
* Sets the domain outer_value to be a custom string.
**/
setOuterValue: AugmentedSubmittable<(domain: Bytes | string | Uint8Array, valueOpt: Option<Bytes> | null | Uint8Array | Bytes | string) => SubmittableExtrinsic<ApiType>, [Bytes, Option<Bytes>]>;
/**
* Add support for a set of top-level domains.
**/
supportTlds: AugmentedSubmittable<(tlds: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;
};
energy: {
/**
* Generate energy for a target account by burning balance from the caller.
**/
generateEnergy: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, burnAmount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;
/**
* Updates the value coefficient. Only callable by the `UpdateOrigin`.
**/
updateValueCoefficient: AugmentedSubmittable<(newCoefficient: i64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [i64]>;
};
parachainSystem: {
authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
/**
* Set the current validation data.
*
* This should be invoked exactly once per block. It will panic at the finalization
* phase if the call was not invoked.
*
* The dispatch origin for this call must be `Inherent`
*
* As a side effect, this function upgrades the current validation function
* if the appropriate time has come.
**/
setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;
sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
};
polkadotXcm: {
/**
* Execute an XCM message from a local, signed, origin.
*
* An event is deposited indicating whether `msg` could be executed completely or only
* partially.
*
* No more than `max_weight` will be used in its attempted execution. If this is less than the
* maximum amount of weight that the message could take to be executed, then no execution
* attempt will be made.
*
* NOTE: A successful return to this does *not* imply that the `msg` was executed successfully
* to completion; only that *some* of it was executed.
**/
execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;
/**
* Set a safe XCM version (the version that XCM should be encoded with if the most recent
* version a destination can accept is unknown).
*
* - `origin`: Must be Root.
* - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.
**/
forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;
/**
* Ask a location to notify us regarding their XCM version and any changes to it.
*
* - `origin`: Must be Root.
* - `location`: The location to which we should subscribe for XCM version notifications.
**/
forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;
/**
* Require that a particular destination should no longer notify us regarding any XCM
* version changes.
*
* - `origin`: Must be Root.
* - `location`: The location to which we are currently subscribed for XCM version
* notifications which we no longer desire.
**/
forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;
/**
* Extoll that a particular destination can be communicated with through a particular
* version of XCM.
*
* - `origin`: Must be Root.
* - `location`: The destination that is being described.
* - `xcm_version`: The latest version of XCM that `location` supports.
**/
forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;
/**
* Transfer some assets from the local chain to the sovereign account of a destination
* chain and forward a notification XCM.
*
* Fee payment on the destination side is made from the asset in the `assets` vector of
* index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight
* is needed than `weight_limit`, then the operation will fail and the assets send may be
* at risk.
*
* - `origin`: Must be capable of withdrawing the `assets` and executing XCM.
* - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send
* from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.
* - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be
* an `AccountId32` value.
* - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the
* `dest` side.
* - `fee_asset_item`: The index into `assets` of the item which should be used to pay
* fees.
* - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.
**/
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]>;
/**
* Teleport some assets from the local chain to some destination chain.
*
* Fee payment on the destination side is made from the asset in the `assets` vector of
* index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight
* is needed than `weight_limit`, then the operation will fail and the assets send may be
* at risk.
*
* - `origin`: Must be capable of withdrawing the `assets` and executing XCM.
* - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send
* from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.
* - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be
* an `AccountId32` value.
* - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the
* `dest` side. May not be empty.
* - `fee_asset_item`: The index into `assets` of the item which should be used to pay
* fees.
* - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.
**/
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]>;
/**
* Transfer some assets from the local chain to the sovereign account of a destination
* chain and forward a notification XCM.
*
* Fee payment on the destination side is made from the asset in the `assets` vector of
* index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,
* with all fees taken as needed from the asset.
*
* - `origin`: Must be capable of withdrawing the `assets` and executing XCM.
* - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send
* from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.
* - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be
* an `AccountId32` value.
* - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the
* `dest` side.
* - `fee_asset_item`: The index into `assets` of the item which should be used to pay
* fees.
**/
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]>;
send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;
/**
* Teleport some assets from the local chain to some destination chain.
*
* Fee payment on the destination side is made from the asset in the `assets` vector of
* index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,
* with all fees taken as needed from the asset.
*
* - `origin`: Must be capable of withdrawing the `assets` and executing XCM.
* - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send
* from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.
* - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be
* an `AccountId32` value.
* - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the
* `dest` side. May not be empty.
* - `fee_asset_item`: The index into `assets` of the item which should be used to pay
* fees.
**/
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]>;
};
posts: {
createPost: AugmentedSubmittable<(spaceIdOpt: Option<u64> | null | Uint8Array | u64 | AnyNumber, extension: PalletPostsPostExtension | { RegularPost: any } | { Comment: any } | { SharedPost: any } | string | Uint8Array, content: SubsocialSupportContent | { None: any } | { Other: any } | { IPFS: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<u64>, PalletPostsPostExtension, SubsocialSupportContent]>;
forceCreatePost: AugmentedSubmittable<(postId: u64 | AnyNumber | Uint8Array, created: SubsocialSupportWhoAndWhen | { account?: any; block?: any; time?: any } | string | Uint8Array, owner: AccountId32 | string | Uint8Array, extension: PalletPostsPostExtension | { RegularPost: any } | { Comment: any } | { SharedPost: any } | string | Uint8Array, spaceIdOpt: Option<u64> | null | Uint8Array | u64 | AnyNumber, content: SubsocialSupportContent | { None: any } | { Other: any } | { IPFS: any } | string | Uint8Array, hidden: bool | boolean | Uint8Array, upvotesCount: u32 | AnyNumber | Uint8Array, downvotesCount: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, SubsocialSupportWhoAndWhen, AccountId32, PalletPostsPostExtension, Option<u64>, SubsocialSupportContent, bool, u32, u32]>;
forceRemovePost: AugmentedSubmittable<(postId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
forceSetNextPostId: AugmentedSubmittable<(postId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
movePost: AugmentedSubmittable<(postId: u64 | AnyNumber | Uint8Array, newSpaceId: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [u64, Option<u64>]>;
updatePost: AugmentedSubmittable<(postId: u64 | AnyNumber | Uint8Array, update: PalletPostsPostUpdate | { spaceId?: any; content?: any; hidden?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, PalletPostsPostUpdate]>;
};
profiles: {
forceSetSpaceAsProfile: AugmentedSubmittable<(account: AccountId32 | string | Uint8Array, spaceIdOpt: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [AccountId32, Option<u64>]>;
resetProfile: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
setProfile: AugmentedSubmittable<(spaceId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
};
proxy: {
/**
* Register a proxy account for the sender that is able to make calls on its behalf.
*
* The dispatch origin for this call must be _Signed_.
*
* Parameters:
* - `proxy`: The account that the `caller` would like to make a proxy.
* - `proxy_type`: The permissions allowed for this proxy account.
* - `delay`: The announcement period required of the initial proxy. Will generally be
* zero.
*
* # <weight>
* Weight is a function of the number of proxies the user has (P).
* # </weight>
**/
addProxy: AugmentedSubmittable<(delegate: AccountId32 | string | Uint8Array, proxyType: SubsocialParachainRuntimeProxyType | 'Any' | 'DomainRegistrar' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, SubsocialParachainRuntimeProxyType, u32]>;
/**
* Publish the hash of a proxy-call that will be made in the future.
*
* This must be called some number of blocks before the corresponding `proxy` is attempted
* if the delay associated with the proxy relationship is greater than zero.
*
* No more than `MaxPending` announcements may be made at any one time.
*
* This will take a deposit of `AnnouncementDepositFactor` as well as
* `AnnouncementDepositBase` if there are no other pending announcements.
*
* The dispatch origin for this call must be _Signed_ and a proxy of `real`.
*
* Parameters:
* - `real`: The account that the proxy will make a call on behalf of.
* - `call_hash`: The hash of the call to be made by the `real` account.
*
* # <weight>
* Weight is a function of:
* - A: the number of announcements made.
* - P: the number of proxies the user has.
* # </weight>
**/
announce: AugmentedSubmittable<(real: AccountId32 | string | Uint8Array, callHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, H256]>;
/**
* Spawn a fresh new account that is guaranteed to be otherwise inaccessible, and
* initialize it with a proxy of `proxy_type` for `origin` sender.
*
* Requires a `Signed` origin.
*
* - `proxy_type`: The type of the proxy that the sender will be registered as over the
* new account. This will almost always be the most permissive `ProxyType` possible to
* allow for maximum flexibility.
* - `index`: A disambiguation index, in case this is called multiple times in the same
* transaction (e.g. with `utility::batch`). Unless you're using `batch` you probably just
* want to use `0`.
* - `delay`: The announcement period required of the initial proxy. Will generally be
* zero.
*
* Fails with `Duplicate` if this has already been called in this transaction, from the
* same sender, with the same parameters.
*
* Fails if there are insufficient funds to pay for deposit.
*
* # <weight>
* Weight is a function of the number of proxies the user has (P).
* # </weight>
* TODO: Might be over counting 1 read
**/
anonymous: AugmentedSubmittable<(proxyType: SubsocialParachainRuntimeProxyType | 'Any' | 'DomainRegistrar' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array, index: u16 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [SubsocialParachainRuntimeProxyType, u32, u16]>;
/**
* Removes a previously spawned anonymous proxy.
*
* WARNING: **All access to this account will be lost.** Any funds held in it will be
* inaccessible.
*
* Requires a `Signed` origin, and the sender account must have been created by a call to
* `anonymous` with corresponding parameters.
*
* - `spawner`: The account that originally called `anonymous` to create this account.
* - `index`: The disambiguation index originally passed to `anonymous`. Probably `0`.
* - `proxy_type`: The proxy type originally passed to `anonymous`.
* - `height`: The height of the chain when the call to `anonymous` was processed.
* - `ext_index`: The extrinsic index in which the call to `anonymous` was processed.
*
* Fails with `NoPermission` in case the caller is not a previously created anonymous
* account whose `anonymous` call has corresponding parameters.
*
* # <weight>
* Weight is a function of the number of proxies the user has (P).
* # </weight>
**/
killAnonymous: AugmentedSubmittable<(spawner: AccountId32 | string | Uint8Array, proxyType: SubsocialParachainRuntimeProxyType | 'Any' | 'DomainRegistrar' | number | Uint8Array, index: u16 | AnyNumber | Uint8Array, height: Compact<u32> | AnyNumber | Uint8Array, extIndex: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, SubsocialParachainRuntimeProxyType, u16, Compact<u32>, Compact<u32>]>;
/**
* Dispatch the given `call` from an account that the sender is authorised for through
* `add_proxy`.
*
* Removes any corresponding announcement(s).
*
* The dispatch origin for this call must be _Signed_.
*
* Parameters:
* - `real`: The account that the proxy will make a call on behalf of.
* - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
* - `call`: The call to be made by the `real` account.
*
* # <weight>
* Weight is a function of the number of proxies the user has (P).
* # </weight>
**/
proxy: AugmentedSubmittable<(real: AccountId32 | string | Uint8Array, forceProxyType: Option<SubsocialParachainRuntimeProxyType> | null | Uint8Array | SubsocialParachainRuntimeProxyType | 'Any' | 'DomainRegistrar' | number, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, Option<SubsocialParachainRuntimeProxyType>, Call]>;
/**
* Dispatch the given `call` from an account that the sender is authorized for through
* `add_proxy`.
*
* Removes any corresponding announcement(s).
*
* The dispatch origin for this call must be _Signed_.
*
* Parameters:
* - `real`: The account that the proxy will make a call on behalf of.
* - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
* - `call`: The call to be made by the `real` account.
*
* # <weight>
* Weight is a function of:
* - A: the number of announcements made.
* - P: the number of proxies the user has.
* # </weight>
**/
proxyAnnounced: AugmentedSubmittable<(delegate: AccountId32 | string | Uint8Array, real: AccountId32 | string | Uint8Array, forceProxyType: Option<SubsocialParachainRuntimeProxyType> | null | Uint8Array | SubsocialParachainRuntimeProxyType | 'Any' | 'DomainRegistrar' | number, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, AccountId32, Option<SubsocialParachainRuntimeProxyType>, Call]>;
/**
* Remove the given announcement of a delegate.
*
* May be called by a target (proxied) account to remove a call that one of their delegates
* (`delegate`) has announced they want to execute. The deposit is returned.
*
* The dispatch origin for this call must be _Signed_.
*
* Parameters:
* - `delegate`: The account that previously announced the call.
* - `call_hash`: The hash of the call to be made.
*
* # <weight>
* Weight is a function of:
* - A: the number of announcements made.
* - P: the number of proxies the user has.
* # </weight>
**/
rejectAnnouncement: AugmentedSubmittable<(delegate: AccountId32 | string | Uint8Array, callHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, H256]>;
/**
* Remove a given announcement.
*
* May be called by a proxy account to remove a call they previously announced and return
* the deposit.
*
* The dispatch origin for this call must be _Signed_.
*
* Parameters:
* - `real`: The account that the proxy will make a call on behalf of.
* - `call_hash`: The hash of the call to be made by the `real` account.
*
* # <weight>
* Weight is a function of:
* - A: the number of announcements made.
* - P: the number of proxies the user has.
* # </weight>
**/
removeAnnouncement: AugmentedSubmittable<(real: AccountId32 | string | Uint8Array, callHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, H256]>;
/**
* Unregister all proxy accounts for the sender.
*
* The dispatch origin for this call must be _Signed_.
*
* WARNING: This may be called on accounts created by `anonymous`, however if done, then
* the unreserved fees will be inaccessible. **All access to this account will be lost.**
*
* # <weight>
* Weight is a function of the number of proxies the user has (P).
* # </weight>
**/
removeProxies: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
/**
* Unregister a proxy account for the sender.
*
* The dispatch origin for this call must be _Signed_.
*
* Parameters:
* - `proxy`: The account that the `caller` would like to remove as a proxy.
* - `proxy_type`: The permissions currently enabled for the removed proxy account.
*
* # <weight>
* Weight is a function of the number of proxies the user has (P).
* # </weight>
**/
removeProxy: AugmentedSubmittable<(delegate: AccountId32 | string | Uint8Array, proxyType: SubsocialParachainRuntimeProxyType | 'Any' | 'DomainRegistrar' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, SubsocialParachainRuntimeProxyType, u32]>;
};
reactions: {
createPostReaction: AugmentedSubmittable<(postId: u64 | AnyNumber | Uint8Array, kind: PalletReactionsReactionKind | 'Upvote' | 'Downvote' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, PalletReactionsReactionKind]>;
deletePostReaction: AugmentedSubmittable<(postId: u64 | AnyNumber | Uint8Array, reactionId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;
forceCreatePostReaction: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array, postId: u64 | AnyNumber | Uint8Array, reactionId: u64 | AnyNumber | Uint8Array, created: SubsocialSupportWhoAndWhen | { account?: any; block?: any; time?: any } | string | Uint8Array, reactionKind: PalletReactionsReactionKind | 'Upvote' | 'Downvote' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, u64, u64, SubsocialSupportWhoAndWhen, PalletReactionsReactionKind]>;
forceDeletePostReaction: AugmentedSubmittable<(reactionId: u64 | AnyNumber | Uint8Array, postId: u64 | AnyNumber | Uint8Array, who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64, AccountId32]>;
forceSetNextReactionId: AugmentedSubmittable<(reactionId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
updatePostReaction: AugmentedSubmittable<(postId: u64 | AnyNumber | Uint8Array, reactionId: u64 | AnyNumber | Uint8Array, newKind: PalletReactionsReactionKind | 'Upvote' | 'Downvote' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64, PalletReactionsReactionKind]>;
};
roles: {
/**
* Create a new role, with a list of permissions, within a given space.
*
* `content` can optionally contain additional information associated with a role,
* such as a name, description, and image for a role. This may be useful for end users.
*
* Only the space owner or a user with `ManageRoles` permission can call this dispatch.
**/
createRole: AugmentedSubmittable<(spaceId: u64 | AnyNumber | Uint8Array, timeToLive: Option<u32> | null | Uint8Array | u32 | AnyNumber, content: SubsocialSupportContent | { None: any } | { Other: any } | { IPFS: any } | string | Uint8Array, permissions: Vec<PalletPermissionsSpacePermission> | (PalletPermissionsSpacePermission | 'ManageRoles' | 'RepresentSpaceInternally' | 'RepresentSpaceExternally' | 'UpdateSpace' | 'CreateSubspaces' | 'UpdateOwnSubspaces' | 'DeleteOwnSubspaces' | 'HideOwnSubspaces' | 'UpdateAnySubspace' | 'DeleteAnySubspace' | 'HideAnySubspace' | 'CreatePosts' | 'UpdateOwnPosts' | 'DeleteOwnPosts' | 'HideOwnPosts' | 'UpdateAnyPost' | 'DeleteAnyPost' | 'HideAnyPost' | 'CreateComments' | 'UpdateOwnComments' | 'DeleteOwnComments' | 'HideOwnComments' | 'HideAnyComment' | 'Upvote' | 'Downvote' | 'Share' | 'OverrideSubspacePermissions' | 'OverridePostPermissions' | 'SuggestEntityStatus' | 'UpdateEntityStatus' | 'UpdateSpaceSettings' | number | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u64, Option<u32>, SubsocialSupportContent, Vec<PalletPermissionsSpacePermission>]>;
/**
* Delete a given role and clean all associated storage items.
* Only the space owner or a user with `ManageRoles` permission can call this dispatch.
**/
deleteRole: AugmentedSubmittable<(roleId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
forceCreateRole: AugmentedSubmittable<(created: SubsocialSupportWhoAndWhen | { account?: any; block?: any; time?: any } | string | Uint8Array, roleId: u64 | AnyNumber | Uint8Array, spaceId: u64 | AnyNumber | Uint8Array, disabled: bool | boolean | Uint8Array, content: SubsocialSupportContent | { None: any } | { Other: any } | { IPFS: any } | string | Uint8Array, permissions: BTreeSet<PalletPermissionsSpacePermission>) => SubmittableExtrinsic<ApiType>, [SubsocialSupportWhoAndWhen, u64, u64, bool, SubsocialSupportContent, BTreeSet<PalletPermissionsSpacePermission>]>;
forceGrantRole: AugmentedSubmittable<(roleId: u64 | AnyNumber | Uint8Array, users: Vec<SubsocialSupportUser> | (SubsocialSupportUser | { Account: any } | { Space: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u64, Vec<SubsocialSupportUser>]>;
forceSetNextRoleId: AugmentedSubmittable<(roleId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
/**
* Grant a given role to a list of users.
* Only the space owner or a user with `ManageRoles` permission can call this dispatch.
**/
grantRole: AugmentedSubmittable<(roleId: u64 | AnyNumber | Uint8Array, users: Vec<SubsocialSupportUser> | (SubsocialSupportUser | { Account: any } | { Space: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u64, Vec<SubsocialSupportUser>]>;
/**
* Revoke a given role from a list of users.
* Only the space owner or a user with `ManageRoles` permission can call this dispatch.
**/
revokeRole: AugmentedSubmittable<(roleId: u64 | AnyNumber | Uint8Array, users: Vec<SubsocialSupportUser> | (SubsocialSupportUser | { Account: any } | { Space: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u64, Vec<SubsocialSupportUser>]>;
/**
* Update an existing role by a given id.
* Only the space owner or a user with `ManageRoles` permission can call this dispatch.
**/
updateRole: AugmentedSubmittable<(roleId: u64 | AnyNumber | Uint8Array, update: PalletRolesRoleUpdate | { disabled?: any; content?: any; permissions?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, PalletRolesRoleUpdate]>;
};
session: {
/**
* Removes any session key(s) of the function caller.
*
* This doesn't take effect until the next session.
*
* The dispatch origin of this function must be Signed and the account must be either be
* convertible to a validator ID using the chain's typical addressing system (this usually
* means being a controller account) or directly convertible into a validator ID (which
* usually means being a stash account).
*
* # <weight>
* - Complexity: `O(1)` in number of key types. Actual cost depends on the number of length
* of `T::Keys::key_ids()` which is fixed.
* - DbReads: `T::ValidatorIdOf`, `NextKeys`, `origin account`
* - DbWrites: `NextKeys`, `origin account`
* - DbWrites per key id: `KeyOwner`
* # </weight>
**/
purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
/**
* Sets the session key(s) of the function caller to `keys`.
* Allows an account to set its session key prior to becoming a validator.
* This doesn't take effect until the next session.
*
* The dispatch origin of this function must be signed.
*
* # <weight>
* - Complexity: `O(1)`. Actual cost depends on the number of length of
* `T::Keys::key_ids()` which is fixed.
* - DbReads: `origin account`, `T::ValidatorIdOf`, `NextKeys`
* - DbWrites: `origin account`, `NextKeys`
* - DbReads per key id: `KeyOwner`
* - DbWrites per key id: `KeyOwner`
* # </weight>
**/
setKeys: AugmentedSubmittable<(keys: SubsocialParachainRuntimeSessionKeys | { aura?: any } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SubsocialParachainRuntimeSessionKeys, Bytes]>;
};
spaceFollows: {
followSpace: AugmentedSubmittable<(spaceId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
forceFollowSpace: AugmentedSubmittable<(follower: AccountId32 | string | Uint8Array, spaceId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, u64]>;
unfollowSpace: AugmentedSubmittable<(spaceId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
};
spaceOwnership: {
acceptPendingOwnership: AugmentedSubmittable<(spaceId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
rejectPendingOwnership: AugmentedSubmittable<(spaceId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
transferSpaceOwnership: AugmentedSubmittable<(spaceId: u64 | AnyNumber | Uint8Array, transferTo: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, AccountId32]>;
};
spaces: {
createSpace: AugmentedSubmittable<(content: SubsocialSupportContent | { None: any } | { Other: any } | { IPFS: any } | string | Uint8Array, permissionsOpt: Option<PalletPermissionsSpacePermissions> | null | Uint8Array | PalletPermissionsSpacePermissions | { none?: any; everyone?: any; follower?: any; spaceOwner?: any } | string) => SubmittableExtrinsic<ApiType>, [SubsocialSupportContent, Option<PalletPermissionsSpacePermissions>]>;
forceCreateSpace: AugmentedSubmittable<(spaceId: u64 | AnyNumber | Uint8Array, created: SubsocialSupportWhoAndWhen | { account?: any; block?: any; time?: any } | string | Uint8Array, owner: AccountId32 | string | Uint8Array, content: SubsocialSupportContent | { None: any } | { Other: any } | { IPFS: any } | string | Uint8Array, hidden: bool | boolean | Uint8Array, permissionsOpt: Option<PalletPermissionsSpacePermissions> | null | Uint8Array | PalletPermissionsSpacePermissions | { none?: any; everyone?: any; follower?: any; spaceOwner?: any } | string) => SubmittableExtrinsic<ApiType>, [u64, SubsocialSupportWhoAndWhen, AccountId32, SubsocialSupportContent, bool, Option<PalletPermissionsSpacePermissions>]>;
forceSetNextSpaceId: AugmentedSubmittable<(spaceId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
updateSpace: AugmentedSubmittable<(spaceId: u64 | AnyNumber | Uint8Array, update: PalletSpacesSpaceUpdate | { content?: any; hidden?: any; permissions?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, PalletSpacesSpaceUpdate]>;
};
sudo: {
/**
* Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo
* key.
*
* The dispatch origin for this call must be _Signed_.
*
* # <weight>
* - O(1).
* - Limited storage reads.
* - One DB change.
* # </weight>
**/
setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;
/**
* Authenticates the sudo key and dispatches a function call with `Root` origin.
*
* The dispatch origin for this call must be _Signed_.
*
* # <weight>
* - O(1).
* - Limited storage reads.
* - One DB write (event).
* - Weight of derivative `call` execution + 10,000.
* # </weight>
**/
sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;
/**
* Authenticates the sudo key and dispatches a function call with `Signed` origin from
* a given account.
*
* The dispatch origin for this call must be _Signed_.
*
* # <weight>
* - O(1).
* - Limited storage reads.
* - One DB write (event).
* - Weight of derivative `call` execution + 10,000.
* # </weight>
**/
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]>;
/**
* Authenticates the sudo key and dispatches a function call with `Root` origin.
* This function does not check the weight of the call, and instead allows the
* Sudo user to specify the weight of the call.
*
* The dispatch origin for this call must be _Signed_.
*
* # <weight>
* - O(1).
* - The weight of this call is defined by the caller.
* # </weight>
**/
sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, u64]>;
};
system: {
/**
* A dispatch that will fill the block weight up to the given ratio.
**/
fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;
/**
* Kill all storage items with a key that starts with the given prefix.
*
* **NOTE:** We rely on the Root origin to provide us the number of subkeys under
* the prefix we are removing to accurately calculate the weight of this function.
**/
killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;
/**
* Kill some items from storage.
**/
killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;
/**
* Make some on-chain remark.
*
* # <weight>
* - `O(1)`
* # </weight>
**/
remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
/**
* Make some on-chain remark and emit event.
**/
remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
/**
* Set the new runtime code.
*
* # <weight>
* - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`
* - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is
* expensive).
* - 1 storage write (codec `O(C)`).
* - 1 digest item.
* - 1 event.
* The weight of this function is dependent on the runtime, but generally this is very
* expensive. We will treat this as a full block.
* # </weight>
**/
setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
/**
* Set the new runtime code without doing any checks of the given `code`.
*
* # <weight>
* - `O(C)` where `C` length of `code`
* - 1 storage write (codec `O(C)`).
* - 1 digest item.
* - 1 event.
* The weight of this function is dependent on the runtime. We will treat this as a full
* block. # </weight>
**/
setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
/**
* Set the number of pages in the WebAssembly environment's heap.
**/
setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
/**
* Set some items of storage.
**/
setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;
};
timestamp: {
/**
* Set the current time.
*
* This call should be invoked exactly once per block. It will panic at the finalization
* phase, if this call hasn't been invoked by that time.
*
* The timestamp should be greater than the previous one by the amount specified by
* `MinimumPeriod`.
*
* The dispatch origin for this call must be `Inherent`.
*
* # <weight>
* - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)
* - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in
* `on_finalize`)
* - 1 event handler `on_timestamp_set`. Must be `O(1)`.
* # </weight>
**/
set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;
};
utility: {
/**
* Send a call through an indexed pseudonym of the sender.
*
* Filter from origin are passed along. The call will be dispatched with an origin which
* use the same filter as the origin of this call.
*
* NOTE: If you need to ensure that any account-based filtering is not honored (i.e.
* because you expect `proxy` to have been used prior in the call stack and you do not want
* the call restrictions to apply to any sub-accounts), then use `as_multi_threshold_1`
* in the Multisig pallet instead.
*
* NOTE: Prior to version *12, this was called `as_limited_sub`.
*
* The dispatch origin for this call must be _Signed_.
**/
asDerivative: AugmentedSubmittable<(index: u16 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Call]>;
/**
* Send a batch of dispatch calls.
*
* May be called from any origin.
*
* - `calls`: The calls to be dispatched from the same origin. The number of call must not
* exceed the constant: `batched_calls_limit` (available in constant metadata).
*
* If origin is root then call are dispatch without checking origin filter. (This includes
* bypassing `frame_system::Config::BaseCallFilter`).
*
* # <weight>
* - Complexity: O(C) where C is the number of calls to be batched.
* # </weight>
*
* This will return `Ok` in all circumstances. To determine the success of the batch, an
* event is deposited. If a call failed and the batch was interrupted, then the
* `BatchInterrupted` event is deposited, along with the number of successful calls made
* and the error of the failed call. If all were successful, then the `BatchCompleted`
* event is deposited.
**/
batch: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;
/**
* Send a batch of dispatch calls and atomically execute them.
* The whole transaction will rollback and fail if any of the calls failed.
*
* May be called from any origin.
*
* - `calls`: The calls to be dispatched from the same origin. The number of call must not
* exceed the constant: `batched_calls_limit` (available in constant metadata).
*
* If origin is root then call are dispatch without checking origin filter. (This includes
* bypassing `frame_system::Config::BaseCallFilter`).
*
* # <weight>
* - Complexity: O(C) where C is the number of calls to be batched.
* # </weight>
**/
batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;
/**
* Dispatches a function call with a provided origin.
*
* The dispatch origin for this call must be _Root_.
*
* # <weight>
* - O(1).
* - Limited storage reads.
* - One DB write (event).
* - Weight of derivative `call` execution + T::WeightInfo::dispatch_as().
* # </weight>
**/
dispatchAs: AugmentedSubmittable<(asOrigin: SubsocialParachainRuntimeOriginCaller | { system: any } | { Void: any } | { PolkadotXcm: any } | { CumulusXcm: any } | string | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SubsocialParachainRuntimeOriginCaller, Call]>;
/**
* Send a batch of dispatch calls.
* Unlike `batch`, it allows errors and won't interrupt.
*
* May be called from any origin.
*
* - `calls`: The calls to be dispatched from the same origin. The number of call must not
* exceed the constant: `batched_calls_limit` (available in constant metadata).
*
* If origin is root then call are dispatch without checking origin filter. (This includes
* bypassing `frame_system::Config::BaseCallFilter`).
*
* # <weight>
* - Complexity: O(C) where C is the number of calls to be batched.
* # </weight>
**/
forceBatch: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;
};
vesting: {
/**
* Force a vested transfer.
*
* The dispatch origin for this call must be _Root_.
*
* - `source`: The account whose funds should be transferred.
* - `target`: The account that should be transferred the vested funds.
* - `schedule`: The vesting schedule attached to the transfer.
*
* Emits `VestingCreated`.
*
* NOTE: This will unlock all schedules through the current block.
*
* # <weight>
* - `O(1)`.
* - DbWeight: 4 Reads, 4 Writes
* - Reads: Vesting Storage, Balances Locks, Target Account, Source Account
* - Writes: Vesting Storage, Balances Locks, Target Account, Source Account
* # </weight>
**/
forceVestedTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, schedule: PalletVestingVestingInfo | { locked?: any; perBlock?: any; startingBlock?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, PalletVestingVestingInfo]>;
/**
* Merge two vesting schedules together, creating a new vesting schedule that unlocks over
* the highest possible start and end blocks. If both schedules have already started the
* current block will be used as the schedule start; with the caveat that if one schedule
* is finished by the current block, the other will be treated as the new merged schedule,
* unmodified.
*
* NOTE: If `schedule1_index == schedule2_index` this is a no-op.
* NOTE: This will unlock all schedules through the current block prior to merging.
* NOTE: If both schedules have ended by the current block, no new schedule will be created
* and both will be removed.
*
* Merged schedule attributes:
* - `starting_block`: `MAX(schedule1.starting_block, scheduled2.starting_block,
* current_block)`.
* - `ending_block`: `MAX(schedule1.ending_block, schedule2.ending_block)`.
* - `locked`: `schedule1.locked_at(current_block) + schedule2.locked_at(current_block)`.
*
* The dispatch origin for this call must be _Signed_.
*
* - `schedule1_index`: index of the first schedule to merge.
* - `schedule2_index`: index of the second schedule to merge.
**/
mergeSchedules: AugmentedSubmittable<(schedule1Index: u32 | AnyNumber | Uint8Array, schedule2Index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;
/**
* Unlock any vested funds of the sender account.
*
* The dispatch origin for this call must be _Signed_ and the sender must have funds still
* locked under this pallet.
*
* Emits either `VestingCompleted` or `VestingUpdated`.
*
* # <weight>
* - `O(1)`.
* - DbWeight: 2 Reads, 2 Writes
* - Reads: Vesting Storage, Balances Locks, [Sender Account]
* - Writes: Vesting Storage, Balances Locks, [Sender Account]
* # </weight>
**/
vest: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
/**
* Create a vested transfer.
*
* The dispatch origin for this call must be _Signed_.
*
* - `target`: The account receiving the vested funds.
* - `schedule`: The vesting schedule attached to the transfer.
*
* Emits `VestingCreated`.
*
* NOTE: This will unlock all schedules through the current block.
*
* # <weight>
* - `O(1)`.
* - DbWeight: 3 Reads, 3 Writes
* - Reads: Vesting Storage, Balances Locks, Target Account, [Sender Account]
* - Writes: Vesting Storage, Balances Locks, Target Account, [Sender Account]
* # </weight>
**/
vestedTransfer: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, schedule: PalletVestingVestingInfo | { locked?: any; perBlock?: any; startingBlock?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletVestingVestingInfo]>;
/**
* Unlock any vested funds of a `target` account.
*
* The dispatch origin for this call must be _Signed_.
*
* - `target`: The account whose vested funds should be unlocked. Must have funds still
* locked under this pallet.
*
* Emits either `VestingCompleted` or `VestingUpdated`.
*
* # <weight>
* - `O(1)`.
* - DbWeight: 3 Reads, 3 Writes
* - Reads: Vesting Storage, Balances Locks, Target Account
* - Writes: Vesting Storage, Balances Locks, Target Account
* # </weight>
**/
vestOther: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;
};
xcmpQueue: {
/**
* Resumes all XCM executions for the XCMP queue.
*
* Note that this function doesn't change the status of the in/out bound channels.
*
* - `origin`: Must pass `ControllerOrigin`.
**/
resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
/**
* Services a single overweight XCM.
*
* - `origin`: Must pass `ExecuteOverweightOrigin`.
* - `index`: The index of the overweight XCM to service
* - `weight_limit`: The amount of weight that XCM execution may take.
*
* Errors:
* - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.
* - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.
* - `WeightOverLimit`: XCM execution may use greater `weight_limit`.
*
* Events:
* - `OverweightServiced`: On success.
**/
serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;
/**
* Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.
*
* - `origin`: Must pass `ControllerOrigin`.
**/
suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
/**
* Overwrites the number of pages of messages which must be in the queue after which we drop any further
* messages from the channel.
*
* - `origin`: Must pass `Root`.
* - `new`: Desired value for `QueueConfigData.drop_threshold`
**/
updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
/**
* Overwrites the number of pages of messages which the queue must be reduced to before it signals that
* message sending may recommence after it has been suspended.
*
* - `origin`: Must pass `Root`.
* - `new`: Desired value for `QueueConfigData.resume_threshold`
**/
updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
/**
* Overwrites the number of pages of messages which must be in the queue for the other side to be told to
* suspend their sending.
*
* - `origin`: Must pass `Root`.
* - `new`: Desired value for `QueueConfigData.suspend_value`
**/
updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
/**
* Overwrites the amount of remaining weight under which we stop processing messages.
*
* - `origin`: Must pass `Root`.
* - `new`: Desired value for `QueueConfigData.threshold_weight`
**/
updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
/**
* Overwrites the speed to which the available weight approaches the maximum weight.
* A lower number results in a faster progression. A value of 1 makes the entire weight available initially.
*
* - `origin`: Must pass `Root`.
* - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.
**/
updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
/**
* Overwrite the maximum amount of weight any individual message may consume.
* Messages above this weight go into the overweight queue and may only be serviced explicitly.
*
* - `origin`: Must pass `Root`.
* - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.
**/
updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
};
} // AugmentedSubmittables
} // declare module