@dedot/chaintypes 0.143.0 → 0.145.0

package/paseo/tx.d.ts

@@ -65,6 +65,8 @@ import type {
   PalletNominationPoolsClaimPermission,
   PalletNominationPoolsCommissionChangeRate,
   PalletNominationPoolsCommissionClaimPermission,
+  PalletStakingAsyncRcClientValidatorSetReport,
+  PalletStakingAsyncAhClientOperatingMode,
   PolkadotPrimitivesV8AsyncBackingAsyncBackingParams,
   PolkadotPrimitivesV8ExecutorParams,
   PolkadotPrimitivesV8ApprovalVotingParams,
@@ -77,7 +79,7 @@ import type {
   PolkadotPrimitivesV8PvfCheckStatement,
   PolkadotPrimitivesV8ValidatorAppSignature,
   PolkadotParachainPrimitivesPrimitivesHrmpChannelId,
-  PolkadotPrimitivesV8SlashingDisputeProof,
+  PolkadotPrimitivesVstagingDisputeProof,
   SpRuntimeMultiSigner,
   PalletBrokerCoretimeInterfaceCoreAssignment,
   PolkadotRuntimeParachainsAssignerCoretimePartsOf57600,
@@ -95,6 +97,9 @@ import type {
   SpConsensusBeefyForkVotingProof,
   SpConsensusBeefyFutureBlockVotingProof,
   PolkadotRuntimeParachainsParasParaGenesisArgs,
+  PalletRcMigratorMigrationStage,
+  StagingXcmV5Response,
+  PalletRcMigratorQueuePriority,
 } from './types.js';
 
 export type ChainSubmittableExtrinsic<
@@ -745,7 +750,7 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
     >;
 
     /**
-     * Ensure that the a bulk of pre-images is upgraded.
+     * Ensure that the bulk of pre-images is upgraded.
      *
      * The caller pays no fee if at least 90% of pre-images were successfully updated.
      *
@@ -1068,6 +1073,34 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Poke the deposit reserved for an index.
+     *
+     * The dispatch origin for this call must be _Signed_ and the signing account must have a
+     * non-frozen account `index`.
+     *
+     * The transaction fees is waived if the deposit is changed after poking/reconsideration.
+     *
+     * - `index`: the index whose deposit is to be poked/reconsidered.
+     *
+     * Emits `DepositPoked` if successful.
+     *
+     * @param {number} index
+     **/
+    pokeDeposit: GenericTxCall<
+      Rv,
+      (index: number) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'Indices';
+          palletCall: {
+            name: 'PokeDeposit';
+            params: { index: number };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -1413,6 +1446,8 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
      * period ends. If this leaves an amount actively bonded less than
      * [`asset::existential_deposit`], then it is increased to the full amount.
      *
+     * The stash may be chilled if the ledger total amount falls to 0 after unbonding.
+     *
      * The dispatch origin for this call must be _Signed_ by the controller, not the stash.
      *
      * Once the unlock period is done, you can call `withdraw_unbonded` to actually move
@@ -1838,6 +1873,7 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
      * Can be called by the `T::AdminOrigin`.
      *
      * Parameters: era and indices of the slashes for that era to kill.
+     * They **must** be sorted in ascending order, *and* unique.
      *
      * @param {number} era
      * @param {Array<number>} slashIndices
@@ -2265,29 +2301,75 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
     >;
 
     /**
-     * Adjusts the staking ledger by withdrawing any excess staked amount.
+     * Removes the legacy Staking locks if they exist.
+     *
+     * This removes the legacy lock on the stake with [`Config::OldCurrency`] and creates a
+     * hold on it if needed. If all stake cannot be held, the best effort is made to hold as
+     * much as possible. The remaining stake is forced withdrawn from the ledger.
      *
-     * This function corrects cases where a user's recorded stake in the ledger
-     * exceeds their actual staked funds. This situation can arise due to cases such as
-     * external slashing by another pallet, leading to an inconsistency between the ledger
-     * and the actual stake.
+     * The fee is waived if the migration is successful.
      *
      * @param {AccountId32Like} stash
      **/
-    withdrawOverstake: GenericTxCall<
+    migrateCurrency: GenericTxCall<
       Rv,
       (stash: AccountId32Like) => ChainSubmittableExtrinsic<
         Rv,
         {
           pallet: 'Staking';
           palletCall: {
-            name: 'WithdrawOverstake';
+            name: 'MigrateCurrency';
             params: { stash: AccountId32Like };
           };
         }
       >
     >;
 
+    /**
+     * This function allows governance to manually slash a validator and is a
+     * **fallback mechanism**.
+     *
+     * The dispatch origin must be `T::AdminOrigin`.
+     *
+     * ## Parameters
+     * - `validator_stash` - The stash account of the validator to slash.
+     * - `era` - The era in which the validator was in the active set.
+     * - `slash_fraction` - The percentage of the stake to slash, expressed as a Perbill.
+     *
+     * ## Behavior
+     *
+     * The slash will be applied using the standard slashing mechanics, respecting the
+     * configured `SlashDeferDuration`.
+     *
+     * This means:
+     * - If the validator was already slashed by a higher percentage for the same era, this
+     * slash will have no additional effect.
+     * - If the validator was previously slashed by a lower percentage, only the difference
+     * will be applied.
+     * - The slash will be deferred by `SlashDeferDuration` eras before being enacted.
+     *
+     * @param {AccountId32Like} validatorStash
+     * @param {number} era
+     * @param {Perbill} slashFraction
+     **/
+    manualSlash: GenericTxCall<
+      Rv,
+      (
+        validatorStash: AccountId32Like,
+        era: number,
+        slashFraction: Perbill,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'Staking';
+          palletCall: {
+            name: 'ManualSlash';
+            params: { validatorStash: AccountId32Like; era: number; slashFraction: Perbill };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -3913,6 +3995,78 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Dispatch a fallback call in the event the main call fails to execute.
+     * May be called from any origin except `None`.
+     *
+     * This function first attempts to dispatch the `main` call.
+     * If the `main` call fails, the `fallback` is attemted.
+     * if the fallback is successfully dispatched, the weights of both calls
+     * are accumulated and an event containing the main call error is deposited.
+     *
+     * In the event of a fallback failure the whole call fails
+     * with the weights returned.
+     *
+     * - `main`: The main call to be dispatched. This is the primary action to execute.
+     * - `fallback`: The fallback call to be dispatched in case the `main` call fails.
+     *
+     * ## Dispatch Logic
+     * - If the origin is `root`, both the main and fallback calls are executed without
+     * applying any origin filters.
+     * - If the origin is not `root`, the origin filter is applied to both the `main` and
+     * `fallback` calls.
+     *
+     * ## Use Case
+     * - Some use cases might involve submitting a `batch` type call in either main, fallback
+     * or both.
+     *
+     * @param {PaseoRuntimeRuntimeCallLike} main
+     * @param {PaseoRuntimeRuntimeCallLike} fallback
+     **/
+    ifElse: GenericTxCall<
+      Rv,
+      (
+        main: PaseoRuntimeRuntimeCallLike,
+        fallback: PaseoRuntimeRuntimeCallLike,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'Utility';
+          palletCall: {
+            name: 'IfElse';
+            params: { main: PaseoRuntimeRuntimeCallLike; fallback: PaseoRuntimeRuntimeCallLike };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Dispatches a function call with a provided origin.
+     *
+     * Almost the same as [`Pallet::dispatch_as`] but forwards any error of the inner call.
+     *
+     * The dispatch origin for this call must be _Root_.
+     *
+     * @param {PaseoRuntimeOriginCaller} asOrigin
+     * @param {PaseoRuntimeRuntimeCallLike} call
+     **/
+    dispatchAsFallible: GenericTxCall<
+      Rv,
+      (
+        asOrigin: PaseoRuntimeOriginCaller,
+        call: PaseoRuntimeRuntimeCallLike,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'Utility';
+          palletCall: {
+            name: 'DispatchAsFallible';
+            params: { asOrigin: PaseoRuntimeOriginCaller; call: PaseoRuntimeRuntimeCallLike };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -4280,6 +4434,30 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Poke / Adjust deposits made for proxies and announcements based on current values.
+     * This can be used by accounts to possibly lower their locked amount.
+     *
+     * The dispatch origin for this call must be _Signed_.
+     *
+     * The transaction fee is waived if the deposit amount has changed.
+     *
+     * Emits `DepositPoked` if successful.
+     *
+     **/
+    pokeDeposit: GenericTxCall<
+      Rv,
+      () => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'Proxy';
+          palletCall: {
+            name: 'PokeDeposit';
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -4512,6 +4690,43 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Poke the deposit reserved for an existing multisig operation.
+     *
+     * The dispatch origin for this call must be _Signed_ and must be the original depositor of
+     * the multisig operation.
+     *
+     * The transaction fee is waived if the deposit amount has changed.
+     *
+     * - `threshold`: The total number of approvals needed for this multisig.
+     * - `other_signatories`: The accounts (other than the sender) who are part of the
+     * multisig.
+     * - `call_hash`: The hash of the call this deposit is reserved for.
+     *
+     * Emits `DepositPoked` if successful.
+     *
+     * @param {number} threshold
+     * @param {Array<AccountId32Like>} otherSignatories
+     * @param {FixedBytes<32>} callHash
+     **/
+    pokeDeposit: GenericTxCall<
+      Rv,
+      (
+        threshold: number,
+        otherSignatories: Array<AccountId32Like>,
+        callHash: FixedBytes<32>,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'Multisig';
+          palletCall: {
+            name: 'PokeDeposit';
+            params: { threshold: number; otherSignatories: Array<AccountId32Like>; callHash: FixedBytes<32> };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -5264,21 +5479,15 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
      * This can only be called when [`Phase::Emergency`] is enabled, as an alternative to
      * calling [`Call::set_emergency_election_result`].
      *
-     * @param {number | undefined} maybeMaxVoters
-     * @param {number | undefined} maybeMaxTargets
      **/
     governanceFallback: GenericTxCall<
       Rv,
-      (
-        maybeMaxVoters: number | undefined,
-        maybeMaxTargets: number | undefined,
-      ) => ChainSubmittableExtrinsic<
+      () => ChainSubmittableExtrinsic<
         Rv,
         {
           pallet: 'ElectionProviderMultiPhase';
           palletCall: {
             name: 'GovernanceFallback';
-            params: { maybeMaxVoters: number | undefined; maybeMaxTargets: number | undefined };
           };
         }
       >
@@ -5384,8 +5593,9 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
    **/
   nominationPools: {
     /**
-     * Stake funds with a pool. The amount to bond is transferred from the member to the pool
-     * account and immediately increases the pools bond.
+     * Stake funds with a pool. The amount to bond is delegated (or transferred based on
+     * [`adapter::StakeStrategyType`]) from the member to the pool account and immediately
+     * increases the pool's bond.
      *
      * The method of transferring the amount to the pool account is determined by
      * [`adapter::StakeStrategyType`]. If the pool is configured to use
@@ -5683,13 +5893,13 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
      * The dispatch origin of this call must be signed by the pool nominator or the pool
      * root role.
      *
-     * This directly forward the call to the staking pallet, on behalf of the pool bonded
-     * account.
+     * This directly forwards the call to an implementation of `StakingInterface` (e.g.,
+     * `pallet-staking`) through [`Config::StakeAdapter`], on behalf of the bonded pool.
      *
      * # Note
      *
-     * In addition to a `root` or `nominator` role of `origin`, pool's depositor needs to have
-     * at least `depositor_min_bond` in the pool to start nominating.
+     * In addition to a `root` or `nominator` role of `origin`, the pool's depositor needs to
+     * have at least `depositor_min_bond` in the pool to start nominating.
      *
      * @param {number} poolId
      * @param {Array<AccountId32Like>} validators
@@ -5861,6 +6071,9 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
      * The dispatch origin of this call can be signed by the pool nominator or the pool
      * root role, same as [`Pallet::nominate`].
      *
+     * This directly forwards the call to an implementation of `StakingInterface` (e.g.,
+     * `pallet-staking`) through [`Config::StakeAdapter`], on behalf of the bonded pool.
+     *
      * Under certain conditions, this call can be dispatched permissionlessly (i.e. by any
      * account).
      *
@@ -5869,9 +6082,7 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
      * are unable to unbond.
      *
      * # Conditions for permissioned dispatch:
-     * * The caller has a nominator or root role of the pool.
-     * This directly forward the call to the staking pallet, on behalf of the pool bonded
-     * account.
+     * * The caller is the pool's nominator or root.
      *
      * @param {number} poolId
      **/
@@ -6050,9 +6261,20 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
     /**
      * Claim pending commission.
      *
-     * The dispatch origin of this call must be signed by the `root` role of the pool. Pending
-     * commission is paid out and added to total claimed commission`. Total pending commission
-     * is reset to zero. the current.
+     * The `root` role of the pool is _always_ allowed to claim the pool's commission.
+     *
+     * If the pool has set `CommissionClaimPermission::Permissionless`, then any account can
+     * trigger the process of claiming the pool's commission.
+     *
+     * If the pool has set its `CommissionClaimPermission` to `Account(acc)`, then only
+     * accounts
+     * * `acc`, and
+     * * the pool's root account
+     *
+     * may call this extrinsic on behalf of the pool.
+     *
+     * Pending commissions are paid out and added to the total claimed commission.
+     * The total pending commission is reset to zero.
      *
      * @param {number} poolId
      **/
@@ -6323,6 +6545,69 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
      **/
     [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
   };
+  /**
+   * Pallet `StakingAhClient`'s transaction calls
+   **/
+  stakingAhClient: {
+    /**
+     *
+     * @param {PalletStakingAsyncRcClientValidatorSetReport} report
+     **/
+    validatorSet: GenericTxCall<
+      Rv,
+      (report: PalletStakingAsyncRcClientValidatorSetReport) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'StakingAhClient';
+          palletCall: {
+            name: 'ValidatorSet';
+            params: { report: PalletStakingAsyncRcClientValidatorSetReport };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Allows governance to force set the operating mode of the pallet.
+     *
+     * @param {PalletStakingAsyncAhClientOperatingMode} mode
+     **/
+    setMode: GenericTxCall<
+      Rv,
+      (mode: PalletStakingAsyncAhClientOperatingMode) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'StakingAhClient';
+          palletCall: {
+            name: 'SetMode';
+            params: { mode: PalletStakingAsyncAhClientOperatingMode };
+          };
+        }
+      >
+    >;
+
+    /**
+     * manually do what this pallet was meant to do at the end of the migration.
+     *
+     **/
+    forceOnMigrationEnd: GenericTxCall<
+      Rv,
+      () => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'StakingAhClient';
+          palletCall: {
+            name: 'ForceOnMigrationEnd';
+          };
+        }
+      >
+    >;
+
+    /**
+     * Generic pallet tx call
+     **/
+    [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
+  };
   /**
    * Pallet `Configuration`'s transaction calls
    **/
@@ -7905,13 +8190,13 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
   parasSlashing: {
     /**
      *
-     * @param {PolkadotPrimitivesV8SlashingDisputeProof} disputeProof
+     * @param {PolkadotPrimitivesVstagingDisputeProof} disputeProof
      * @param {SpSessionMembershipProof} keyOwnerProof
      **/
     reportDisputeLostUnsigned: GenericTxCall<
       Rv,
       (
-        disputeProof: PolkadotPrimitivesV8SlashingDisputeProof,
+        disputeProof: PolkadotPrimitivesVstagingDisputeProof,
         keyOwnerProof: SpSessionMembershipProof,
       ) => ChainSubmittableExtrinsic<
         Rv,
@@ -7919,7 +8204,7 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
           pallet: 'ParasSlashing';
           palletCall: {
             name: 'ReportDisputeLostUnsigned';
-            params: { disputeProof: PolkadotPrimitivesV8SlashingDisputeProof; keyOwnerProof: SpSessionMembershipProof };
+            params: { disputeProof: PolkadotPrimitivesVstagingDisputeProof; keyOwnerProof: SpSessionMembershipProof };
           };
         }
       >
@@ -8008,6 +8293,45 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Create a single on demand core order with credits.
+     * Will charge the owner's on-demand credit account the spot price for the current block.
+     *
+     * Parameters:
+     * - `origin`: The sender of the call, on-demand credits will be withdrawn from this
+     * account.
+     * - `max_amount`: The maximum number of credits to spend from the origin to place an
+     * order.
+     * - `para_id`: A `ParaId` the origin wants to provide blockspace for.
+     *
+     * Errors:
+     * - `InsufficientCredits`
+     * - `QueueFull`
+     * - `SpotPriceHigherThanMaxAmount`
+     *
+     * Events:
+     * - `OnDemandOrderPlaced`
+     *
+     * @param {bigint} maxAmount
+     * @param {PolkadotParachainPrimitivesPrimitivesId} paraId
+     **/
+    placeOrderWithCredits: GenericTxCall<
+      Rv,
+      (
+        maxAmount: bigint,
+        paraId: PolkadotParachainPrimitivesPrimitivesId,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'OnDemand';
+          palletCall: {
+            name: 'PlaceOrderWithCredits';
+            params: { maxAmount: bigint; paraId: PolkadotParachainPrimitivesPrimitivesId };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -8830,6 +9154,28 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     *
+     * @param {AccountId32Like} who
+     * @param {bigint} amount
+     **/
+    creditAccount: GenericTxCall<
+      Rv,
+      (
+        who: AccountId32Like,
+        amount: bigint,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'Coretime';
+          palletCall: {
+            name: 'CreditAccount';
+            params: { who: AccountId32Like; amount: bigint };
+          };
+        }
+      >
+    >;
+
     /**
      * Receive instructions from the `ExternalBrokerOrigin`, detailing how a specific core is
      * to be used.
@@ -9648,6 +9994,77 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Authorize another `aliaser` location to alias into the local `origin` making this call.
+     * The `aliaser` is only authorized until the provided `expiry` block number.
+     * The call can also be used for a previously authorized alias in order to update its
+     * `expiry` block number.
+     *
+     * Usually useful to allow your local account to be aliased into from a remote location
+     * also under your control (like your account on another chain).
+     *
+     * WARNING: make sure the caller `origin` (you) trusts the `aliaser` location to act in
+     * their/your name. Once authorized using this call, the `aliaser` can freely impersonate
+     * `origin` in XCM programs executed on the local chain.
+     *
+     * @param {XcmVersionedLocation} aliaser
+     * @param {bigint | undefined} expires
+     **/
+    addAuthorizedAlias: GenericTxCall<
+      Rv,
+      (
+        aliaser: XcmVersionedLocation,
+        expires: bigint | undefined,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'XcmPallet';
+          palletCall: {
+            name: 'AddAuthorizedAlias';
+            params: { aliaser: XcmVersionedLocation; expires: bigint | undefined };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Remove a previously authorized `aliaser` from the list of locations that can alias into
+     * the local `origin` making this call.
+     *
+     * @param {XcmVersionedLocation} aliaser
+     **/
+    removeAuthorizedAlias: GenericTxCall<
+      Rv,
+      (aliaser: XcmVersionedLocation) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'XcmPallet';
+          palletCall: {
+            name: 'RemoveAuthorizedAlias';
+            params: { aliaser: XcmVersionedLocation };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Remove all previously authorized `aliaser`s that can alias into the local `origin`
+     * making this call.
+     *
+     **/
+    removeAllAuthorizedAliases: GenericTxCall<
+      Rv,
+      () => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'XcmPallet';
+          palletCall: {
+            name: 'RemoveAllAuthorizedAliases';
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -10288,6 +10705,240 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Generic pallet tx call
+     **/
+    [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
+  };
+  /**
+   * Pallet `RcMigrator`'s transaction calls
+   **/
+  rcMigrator: {
+    /**
+     * Set the migration stage.
+     *
+     * This call is intended for emergency use only and is guarded by the
+     * [`Config::AdminOrigin`].
+     *
+     * @param {PalletRcMigratorMigrationStage} stage
+     **/
+    forceSetStage: GenericTxCall<
+      Rv,
+      (stage: PalletRcMigratorMigrationStage) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'ForceSetStage';
+            params: { stage: PalletRcMigratorMigrationStage };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Schedule the migration to start at a given moment.
+     *
+     * ### Parameters:
+     * - `start`: The block number at which the migration will start. `DispatchTime` calculated
+     * at the moment of the extrinsic execution.
+     * - `warm_up`: Duration or timepoint that will be used to prepare for the migration. Calls
+     * are filtered during this period. It is intended to give enough time for UMP and DMP
+     * queues to empty. `DispatchTime` calculated at the moment of the transition to the
+     * warm-up stage.
+     * - `cool_off`: The block number at which the post migration cool-off period will end. The
+     * `DispatchTime` calculated at the moment of the transition to the cool-off stage.
+     * - `unsafe_ignore_staking_lock_check`: ONLY FOR TESTING. Ignore the check whether the
+     * scheduled time point is far enough in the future.
+     *
+     * Note: If the staking election for next era is already complete, and the next
+     * validator set is queued in `pallet-session`, we want to avoid starting the data
+     * migration at this point as it can lead to some missed validator rewards. To address
+     * this, we stop staking election at the start of migration and must wait atleast 1
+     * session (set via warm_up) before starting the data migration.
+     *
+     * Read [`MigrationStage::Scheduled`] documentation for more details.
+     *
+     * @param {FrameSupportScheduleDispatchTime} start
+     * @param {FrameSupportScheduleDispatchTime} warmUp
+     * @param {FrameSupportScheduleDispatchTime} coolOff
+     * @param {boolean} unsafeIgnoreStakingLockCheck
+     **/
+    scheduleMigration: GenericTxCall<
+      Rv,
+      (
+        start: FrameSupportScheduleDispatchTime,
+        warmUp: FrameSupportScheduleDispatchTime,
+        coolOff: FrameSupportScheduleDispatchTime,
+        unsafeIgnoreStakingLockCheck: boolean,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'ScheduleMigration';
+            params: {
+              start: FrameSupportScheduleDispatchTime;
+              warmUp: FrameSupportScheduleDispatchTime;
+              coolOff: FrameSupportScheduleDispatchTime;
+              unsafeIgnoreStakingLockCheck: boolean;
+            };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Start the data migration.
+     *
+     * This is typically called by the Asset Hub to indicate it's readiness to receive the
+     * migration data.
+     *
+     **/
+    startDataMigration: GenericTxCall<
+      Rv,
+      () => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'StartDataMigration';
+          };
+        }
+      >
+    >;
+
+    /**
+     * Receive a query response from the Asset Hub for a previously sent xcm message.
+     *
+     * @param {bigint} queryId
+     * @param {StagingXcmV5Response} response
+     **/
+    receiveQueryResponse: GenericTxCall<
+      Rv,
+      (
+        queryId: bigint,
+        response: StagingXcmV5Response,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'ReceiveQueryResponse';
+            params: { queryId: bigint; response: StagingXcmV5Response };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Resend a previously sent and unconfirmed XCM message.
+     *
+     * @param {bigint} queryId
+     **/
+    resendXcm: GenericTxCall<
+      Rv,
+      (queryId: bigint) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'ResendXcm';
+            params: { queryId: bigint };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Set the unprocessed message buffer size.
+     *
+     * `None` means to use the configuration value.
+     *
+     * @param {number | undefined} new_
+     **/
+    setUnprocessedMsgBuffer: GenericTxCall<
+      Rv,
+      (new_: number | undefined) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'SetUnprocessedMsgBuffer';
+            params: { new: number | undefined };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Set the AH UMP queue priority configuration.
+     *
+     * Can only be called by the `AdminOrigin`.
+     *
+     * @param {PalletRcMigratorQueuePriority} new_
+     **/
+    setAhUmpQueuePriority: GenericTxCall<
+      Rv,
+      (new_: PalletRcMigratorQueuePriority) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'SetAhUmpQueuePriority';
+            params: { new: PalletRcMigratorQueuePriority };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Set the manager account id.
+     *
+     * The manager has the similar to [`Config::AdminOrigin`] privileges except that it
+     * can not set the manager account id via `set_manager` call.
+     *
+     * @param {AccountId32Like | undefined} new_
+     **/
+    setManager: GenericTxCall<
+      Rv,
+      (new_: AccountId32Like | undefined) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'SetManager';
+            params: { new: AccountId32Like | undefined };
+          };
+        }
+      >
+    >;
+
+    /**
+     * XCM send call identical to the [`pallet_xcm::Pallet::send`] call but with the
+     * [Config::SendXcm] router which will be able to send messages to the Asset Hub during
+     * the migration.
+     *
+     * @param {XcmVersionedLocation} dest
+     * @param {XcmVersionedXcm} message
+     **/
+    sendXcmMessage: GenericTxCall<
+      Rv,
+      (
+        dest: XcmVersionedLocation,
+        message: XcmVersionedXcm,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'SendXcmMessage';
+            params: { dest: XcmVersionedLocation; message: XcmVersionedXcm };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/