@wandelbots/nova-api 25.11.0-dev.29 → 25.11.0-dev.30

package/dist/v1/index.cjs

@@ -4754,7 +4754,7 @@ var MotionApi = class extends BaseAPI {
 		return MotionApiFp(this.configuration).planTrajectory(cell, planTrajectoryRequest, options).then((request) => request(this.axios, this.basePath));
 	}
 	/**
-	* Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. The active movement request returns until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
+	* Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. This call will immediately return even if the deceleration is still in progress. The active movement stream returns responses until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
 	* @summary Stop
 	* @param {string} cell Unique identifier addressing a cell in all API calls. 
 	* @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.

package/dist/v1/index.d.cts

@@ -7,7 +7,7 @@ import { AxiosInstance, AxiosPromise, RawAxiosRequestConfig } from "axios";
  * Wandelbots NOVA API
  * Interact with robots in an easy and intuitive way.
  *
- * The version of the OpenAPI document: 1.1.0
+ * The version of the OpenAPI document: 1.2.0 dev
  *
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -6569,7 +6569,7 @@ declare const MotionApiAxiosParamCreator: (configuration?: Configuration) => {
    */
   planTrajectory: (cell: string, planTrajectoryRequest?: PlanTrajectoryRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
   /**
-   * Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. The active movement request returns until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
+   * Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. This call will immediately return even if the deceleration is still in progress. The active movement stream returns responses until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
    * @summary Stop
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
@@ -6749,7 +6749,7 @@ declare const MotionApiFp: (configuration?: Configuration) => {
    */
   planTrajectory(cell: string, planTrajectoryRequest?: PlanTrajectoryRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PlanTrajectoryResponse>>;
   /**
-   * Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. The active movement request returns until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
+   * Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. This call will immediately return even if the deceleration is still in progress. The active movement stream returns responses until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
    * @summary Stop
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
@@ -6929,7 +6929,7 @@ declare const MotionApiFactory: (configuration?: Configuration, basePath?: strin
    */
   planTrajectory(cell: string, planTrajectoryRequest?: PlanTrajectoryRequest, options?: RawAxiosRequestConfig): AxiosPromise<PlanTrajectoryResponse>;
   /**
-   * Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. The active movement request returns until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
+   * Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. This call will immediately return even if the deceleration is still in progress. The active movement stream returns responses until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
    * @summary Stop
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
@@ -7109,7 +7109,7 @@ declare class MotionApi extends BaseAPI {
    */
   planTrajectory(cell: string, planTrajectoryRequest?: PlanTrajectoryRequest, options?: RawAxiosRequestConfig): Promise<axios131.AxiosResponse<PlanTrajectoryResponse, any>>;
   /**
-   * Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. The active movement request returns until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
+   * Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. This call will immediately return even if the deceleration is still in progress. The active movement stream returns responses until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
    * @summary Stop
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.

package/dist/v1/index.d.ts

@@ -7,7 +7,7 @@ import { AxiosInstance, AxiosPromise, RawAxiosRequestConfig } from "axios";
  * Wandelbots NOVA API
  * Interact with robots in an easy and intuitive way.
  *
- * The version of the OpenAPI document: 1.1.0
+ * The version of the OpenAPI document: 1.2.0 dev
  *
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -6569,7 +6569,7 @@ declare const MotionApiAxiosParamCreator: (configuration?: Configuration) => {
    */
   planTrajectory: (cell: string, planTrajectoryRequest?: PlanTrajectoryRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
   /**
-   * Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. The active movement request returns until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
+   * Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. This call will immediately return even if the deceleration is still in progress. The active movement stream returns responses until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
    * @summary Stop
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
@@ -6749,7 +6749,7 @@ declare const MotionApiFp: (configuration?: Configuration) => {
    */
   planTrajectory(cell: string, planTrajectoryRequest?: PlanTrajectoryRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PlanTrajectoryResponse>>;
   /**
-   * Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. The active movement request returns until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
+   * Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. This call will immediately return even if the deceleration is still in progress. The active movement stream returns responses until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
    * @summary Stop
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
@@ -6929,7 +6929,7 @@ declare const MotionApiFactory: (configuration?: Configuration, basePath?: strin
    */
   planTrajectory(cell: string, planTrajectoryRequest?: PlanTrajectoryRequest, options?: RawAxiosRequestConfig): AxiosPromise<PlanTrajectoryResponse>;
   /**
-   * Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. The active movement request returns until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
+   * Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. This call will immediately return even if the deceleration is still in progress. The active movement stream returns responses until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
    * @summary Stop
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.
@@ -7109,7 +7109,7 @@ declare class MotionApi extends BaseAPI {
    */
   planTrajectory(cell: string, planTrajectoryRequest?: PlanTrajectoryRequest, options?: RawAxiosRequestConfig): Promise<axios131.AxiosResponse<PlanTrajectoryResponse, any>>;
   /**
-   * Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. The active movement request returns until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
+   * Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. This call will immediately return even if the deceleration is still in progress. The active movement stream returns responses until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
    * @summary Stop
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.

package/dist/v1/index.js

@@ -4752,7 +4752,7 @@ var MotionApi = class extends BaseAPI {
 		return MotionApiFp(this.configuration).planTrajectory(cell, planTrajectoryRequest, options).then((request) => request(this.axios, this.basePath));
 	}
 	/**
-	* Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. The active movement request returns until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
+	* Stops an active motion gracefully with deceleration until standstill while staying on the planned trajectory. When an active movement is stopped any further update request will be rejected. This call will immediately return even if the deceleration is still in progress. The active movement stream returns responses until the robot has reached standstill. Currently it is not possible to restart the motion. Please send in a feature request if you need to restart/continue the motion.
 	* @summary Stop
 	* @param {string} cell Unique identifier addressing a cell in all API calls. 
 	* @param {string} motion This represents the UUID of a motion. Every executable or partially executable motion is cached and an UUID is returned. Indicate the UUID to execute the motion or retrieve information on the motion.

package/dist/v2/index.cjs

@@ -3217,7 +3217,7 @@ const JoggingApiFactory = function(configuration, basePath, axios$1) {
 */
 var JoggingApi = class extends BaseAPI {
 	/**
-	* <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. 
+	* <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  - Commands can only be processed in the cycle rate of the controller - Sending commands faster will not increase the responsiveness of the jogging motion, it will lead to dropped commands - It is recommended to couple sending commands with the (state stream)[streamMotionGroupState], which can be subscribed to via nats as well.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. 
 	* @summary Execute Jogging
 	* @param {string} cell Unique identifier addressing a cell in all API calls. 
 	* @param {string} controller Unique identifier to address a controller in the cell.
@@ -6193,7 +6193,7 @@ const TrajectoryExecutionApiFactory = function(configuration, basePath, axios$1)
 */
 var TrajectoryExecutionApi = class extends BaseAPI {
 	/**
-	* <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  - `InitializeMovementResponse` is sent to signal the success or failure of the `InitializeMovementRequest`. - Movement responses are streamed after a `StartMovementRequest` successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by `InitializeMovementRequest`. - Standstill response is sent once the movement has finished or has come to a standstill due to a pause. - `PauseMovementResponse` is sent to signal the success of the `PauseMovementRequest`. It does not signal the end of the movement.   End of movement is signaled by Standstill response. - `PlaybackSpeedResponse` is sent to signal the success of the `PlaybackSpeedRequest`. - `MovementError` with error details is sent in case of an unexpected error, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished. 
+	* <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time.   Pausing the current movement enables you to send another `InitializeMovementRequest` to execute another trajectory on the same connection.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  To monitor the state of the movement, listen to the [state stream](streamMotionGroupState). The state is published via nats as well. Field `execute` in the `MotionGroupState` indicates whether a movement is ongoing and carries execution details.  Each request has a corresponding acknowledgment response. They signal success or failure of the request. Especially for `PauseMovementResponse`, it does not signal the end of the movement.  Additionally, `MovementError` messages can be sent in case of unexpected errors during the execution, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished. 
 	* @summary Execute Trajectory
 	* @param {string} cell Unique identifier addressing a cell in all API calls. 
 	* @param {string} controller Unique identifier to address a controller in the cell.

package/dist/v2/index.d.cts

@@ -5280,7 +5280,7 @@ declare class ControllerInputsOutputsApi extends BaseAPI {
  */
 declare const JoggingApiAxiosParamCreator: (configuration?: Configuration) => {
   /**
-   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
+   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  - Commands can only be processed in the cycle rate of the controller - Sending commands faster will not increase the responsiveness of the jogging motion, it will lead to dropped commands - It is recommended to couple sending commands with the (state stream)[streamMotionGroupState], which can be subscribed to via nats as well.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
    * @summary Execute Jogging
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} controller Unique identifier to address a controller in the cell.
@@ -5295,7 +5295,7 @@ declare const JoggingApiAxiosParamCreator: (configuration?: Configuration) => {
  */
 declare const JoggingApiFp: (configuration?: Configuration) => {
   /**
-   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
+   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  - Commands can only be processed in the cycle rate of the controller - Sending commands faster will not increase the responsiveness of the jogging motion, it will lead to dropped commands - It is recommended to couple sending commands with the (state stream)[streamMotionGroupState], which can be subscribed to via nats as well.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
    * @summary Execute Jogging
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} controller Unique identifier to address a controller in the cell.
@@ -5310,7 +5310,7 @@ declare const JoggingApiFp: (configuration?: Configuration) => {
  */
 declare const JoggingApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
   /**
-   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
+   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  - Commands can only be processed in the cycle rate of the controller - Sending commands faster will not increase the responsiveness of the jogging motion, it will lead to dropped commands - It is recommended to couple sending commands with the (state stream)[streamMotionGroupState], which can be subscribed to via nats as well.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
    * @summary Execute Jogging
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} controller Unique identifier to address a controller in the cell.
@@ -5325,7 +5325,7 @@ declare const JoggingApiFactory: (configuration?: Configuration, basePath?: stri
  */
 declare class JoggingApi extends BaseAPI {
   /**
-   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
+   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  - Commands can only be processed in the cycle rate of the controller - Sending commands faster will not increase the responsiveness of the jogging motion, it will lead to dropped commands - It is recommended to couple sending commands with the (state stream)[streamMotionGroupState], which can be subscribed to via nats as well.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
    * @summary Execute Jogging
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} controller Unique identifier to address a controller in the cell.
@@ -7554,7 +7554,7 @@ declare class TrajectoryCachingApi extends BaseAPI {
  */
 declare const TrajectoryExecutionApiAxiosParamCreator: (configuration?: Configuration) => {
   /**
-   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  - `InitializeMovementResponse` is sent to signal the success or failure of the `InitializeMovementRequest`. - Movement responses are streamed after a `StartMovementRequest` successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by `InitializeMovementRequest`. - Standstill response is sent once the movement has finished or has come to a standstill due to a pause. - `PauseMovementResponse` is sent to signal the success of the `PauseMovementRequest`. It does not signal the end of the movement.   End of movement is signaled by Standstill response. - `PlaybackSpeedResponse` is sent to signal the success of the `PlaybackSpeedRequest`. - `MovementError` with error details is sent in case of an unexpected error, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished.
+   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time.   Pausing the current movement enables you to send another `InitializeMovementRequest` to execute another trajectory on the same connection.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  To monitor the state of the movement, listen to the [state stream](streamMotionGroupState). The state is published via nats as well. Field `execute` in the `MotionGroupState` indicates whether a movement is ongoing and carries execution details.  Each request has a corresponding acknowledgment response. They signal success or failure of the request. Especially for `PauseMovementResponse`, it does not signal the end of the movement.  Additionally, `MovementError` messages can be sent in case of unexpected errors during the execution, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished.
    * @summary Execute Trajectory
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} controller Unique identifier to address a controller in the cell.
@@ -7569,7 +7569,7 @@ declare const TrajectoryExecutionApiAxiosParamCreator: (configuration?: Configur
  */
 declare const TrajectoryExecutionApiFp: (configuration?: Configuration) => {
   /**
-   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  - `InitializeMovementResponse` is sent to signal the success or failure of the `InitializeMovementRequest`. - Movement responses are streamed after a `StartMovementRequest` successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by `InitializeMovementRequest`. - Standstill response is sent once the movement has finished or has come to a standstill due to a pause. - `PauseMovementResponse` is sent to signal the success of the `PauseMovementRequest`. It does not signal the end of the movement.   End of movement is signaled by Standstill response. - `PlaybackSpeedResponse` is sent to signal the success of the `PlaybackSpeedRequest`. - `MovementError` with error details is sent in case of an unexpected error, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished.
+   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time.   Pausing the current movement enables you to send another `InitializeMovementRequest` to execute another trajectory on the same connection.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  To monitor the state of the movement, listen to the [state stream](streamMotionGroupState). The state is published via nats as well. Field `execute` in the `MotionGroupState` indicates whether a movement is ongoing and carries execution details.  Each request has a corresponding acknowledgment response. They signal success or failure of the request. Especially for `PauseMovementResponse`, it does not signal the end of the movement.  Additionally, `MovementError` messages can be sent in case of unexpected errors during the execution, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished.
    * @summary Execute Trajectory
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} controller Unique identifier to address a controller in the cell.
@@ -7584,7 +7584,7 @@ declare const TrajectoryExecutionApiFp: (configuration?: Configuration) => {
  */
 declare const TrajectoryExecutionApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
   /**
-   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  - `InitializeMovementResponse` is sent to signal the success or failure of the `InitializeMovementRequest`. - Movement responses are streamed after a `StartMovementRequest` successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by `InitializeMovementRequest`. - Standstill response is sent once the movement has finished or has come to a standstill due to a pause. - `PauseMovementResponse` is sent to signal the success of the `PauseMovementRequest`. It does not signal the end of the movement.   End of movement is signaled by Standstill response. - `PlaybackSpeedResponse` is sent to signal the success of the `PlaybackSpeedRequest`. - `MovementError` with error details is sent in case of an unexpected error, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished.
+   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time.   Pausing the current movement enables you to send another `InitializeMovementRequest` to execute another trajectory on the same connection.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  To monitor the state of the movement, listen to the [state stream](streamMotionGroupState). The state is published via nats as well. Field `execute` in the `MotionGroupState` indicates whether a movement is ongoing and carries execution details.  Each request has a corresponding acknowledgment response. They signal success or failure of the request. Especially for `PauseMovementResponse`, it does not signal the end of the movement.  Additionally, `MovementError` messages can be sent in case of unexpected errors during the execution, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished.
    * @summary Execute Trajectory
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} controller Unique identifier to address a controller in the cell.
@@ -7599,7 +7599,7 @@ declare const TrajectoryExecutionApiFactory: (configuration?: Configuration, bas
  */
 declare class TrajectoryExecutionApi extends BaseAPI {
   /**
-   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  - `InitializeMovementResponse` is sent to signal the success or failure of the `InitializeMovementRequest`. - Movement responses are streamed after a `StartMovementRequest` successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by `InitializeMovementRequest`. - Standstill response is sent once the movement has finished or has come to a standstill due to a pause. - `PauseMovementResponse` is sent to signal the success of the `PauseMovementRequest`. It does not signal the end of the movement.   End of movement is signaled by Standstill response. - `PlaybackSpeedResponse` is sent to signal the success of the `PlaybackSpeedRequest`. - `MovementError` with error details is sent in case of an unexpected error, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished.
+   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time.   Pausing the current movement enables you to send another `InitializeMovementRequest` to execute another trajectory on the same connection.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  To monitor the state of the movement, listen to the [state stream](streamMotionGroupState). The state is published via nats as well. Field `execute` in the `MotionGroupState` indicates whether a movement is ongoing and carries execution details.  Each request has a corresponding acknowledgment response. They signal success or failure of the request. Especially for `PauseMovementResponse`, it does not signal the end of the movement.  Additionally, `MovementError` messages can be sent in case of unexpected errors during the execution, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished.
    * @summary Execute Trajectory
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} controller Unique identifier to address a controller in the cell.

package/dist/v2/index.d.ts

@@ -5280,7 +5280,7 @@ declare class ControllerInputsOutputsApi extends BaseAPI {
  */
 declare const JoggingApiAxiosParamCreator: (configuration?: Configuration) => {
   /**
-   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
+   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  - Commands can only be processed in the cycle rate of the controller - Sending commands faster will not increase the responsiveness of the jogging motion, it will lead to dropped commands - It is recommended to couple sending commands with the (state stream)[streamMotionGroupState], which can be subscribed to via nats as well.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
    * @summary Execute Jogging
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} controller Unique identifier to address a controller in the cell.
@@ -5295,7 +5295,7 @@ declare const JoggingApiAxiosParamCreator: (configuration?: Configuration) => {
  */
 declare const JoggingApiFp: (configuration?: Configuration) => {
   /**
-   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
+   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  - Commands can only be processed in the cycle rate of the controller - Sending commands faster will not increase the responsiveness of the jogging motion, it will lead to dropped commands - It is recommended to couple sending commands with the (state stream)[streamMotionGroupState], which can be subscribed to via nats as well.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
    * @summary Execute Jogging
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} controller Unique identifier to address a controller in the cell.
@@ -5310,7 +5310,7 @@ declare const JoggingApiFp: (configuration?: Configuration) => {
  */
 declare const JoggingApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
   /**
-   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
+   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  - Commands can only be processed in the cycle rate of the controller - Sending commands faster will not increase the responsiveness of the jogging motion, it will lead to dropped commands - It is recommended to couple sending commands with the (state stream)[streamMotionGroupState], which can be subscribed to via nats as well.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
    * @summary Execute Jogging
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} controller Unique identifier to address a controller in the cell.
@@ -5325,7 +5325,7 @@ declare const JoggingApiFactory: (configuration?: Configuration, basePath?: stri
  */
 declare class JoggingApi extends BaseAPI {
   /**
-   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
+   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  - Commands can only be processed in the cycle rate of the controller - Sending commands faster will not increase the responsiveness of the jogging motion, it will lead to dropped commands - It is recommended to couple sending commands with the (state stream)[streamMotionGroupState], which can be subscribed to via nats as well.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
    * @summary Execute Jogging
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} controller Unique identifier to address a controller in the cell.
@@ -7554,7 +7554,7 @@ declare class TrajectoryCachingApi extends BaseAPI {
  */
 declare const TrajectoryExecutionApiAxiosParamCreator: (configuration?: Configuration) => {
   /**
-   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  - `InitializeMovementResponse` is sent to signal the success or failure of the `InitializeMovementRequest`. - Movement responses are streamed after a `StartMovementRequest` successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by `InitializeMovementRequest`. - Standstill response is sent once the movement has finished or has come to a standstill due to a pause. - `PauseMovementResponse` is sent to signal the success of the `PauseMovementRequest`. It does not signal the end of the movement.   End of movement is signaled by Standstill response. - `PlaybackSpeedResponse` is sent to signal the success of the `PlaybackSpeedRequest`. - `MovementError` with error details is sent in case of an unexpected error, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished.
+   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time.   Pausing the current movement enables you to send another `InitializeMovementRequest` to execute another trajectory on the same connection.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  To monitor the state of the movement, listen to the [state stream](streamMotionGroupState). The state is published via nats as well. Field `execute` in the `MotionGroupState` indicates whether a movement is ongoing and carries execution details.  Each request has a corresponding acknowledgment response. They signal success or failure of the request. Especially for `PauseMovementResponse`, it does not signal the end of the movement.  Additionally, `MovementError` messages can be sent in case of unexpected errors during the execution, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished.
    * @summary Execute Trajectory
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} controller Unique identifier to address a controller in the cell.
@@ -7569,7 +7569,7 @@ declare const TrajectoryExecutionApiAxiosParamCreator: (configuration?: Configur
  */
 declare const TrajectoryExecutionApiFp: (configuration?: Configuration) => {
   /**
-   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  - `InitializeMovementResponse` is sent to signal the success or failure of the `InitializeMovementRequest`. - Movement responses are streamed after a `StartMovementRequest` successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by `InitializeMovementRequest`. - Standstill response is sent once the movement has finished or has come to a standstill due to a pause. - `PauseMovementResponse` is sent to signal the success of the `PauseMovementRequest`. It does not signal the end of the movement.   End of movement is signaled by Standstill response. - `PlaybackSpeedResponse` is sent to signal the success of the `PlaybackSpeedRequest`. - `MovementError` with error details is sent in case of an unexpected error, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished.
+   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time.   Pausing the current movement enables you to send another `InitializeMovementRequest` to execute another trajectory on the same connection.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  To monitor the state of the movement, listen to the [state stream](streamMotionGroupState). The state is published via nats as well. Field `execute` in the `MotionGroupState` indicates whether a movement is ongoing and carries execution details.  Each request has a corresponding acknowledgment response. They signal success or failure of the request. Especially for `PauseMovementResponse`, it does not signal the end of the movement.  Additionally, `MovementError` messages can be sent in case of unexpected errors during the execution, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished.
    * @summary Execute Trajectory
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} controller Unique identifier to address a controller in the cell.
@@ -7584,7 +7584,7 @@ declare const TrajectoryExecutionApiFp: (configuration?: Configuration) => {
  */
 declare const TrajectoryExecutionApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
   /**
-   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  - `InitializeMovementResponse` is sent to signal the success or failure of the `InitializeMovementRequest`. - Movement responses are streamed after a `StartMovementRequest` successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by `InitializeMovementRequest`. - Standstill response is sent once the movement has finished or has come to a standstill due to a pause. - `PauseMovementResponse` is sent to signal the success of the `PauseMovementRequest`. It does not signal the end of the movement.   End of movement is signaled by Standstill response. - `PlaybackSpeedResponse` is sent to signal the success of the `PlaybackSpeedRequest`. - `MovementError` with error details is sent in case of an unexpected error, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished.
+   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time.   Pausing the current movement enables you to send another `InitializeMovementRequest` to execute another trajectory on the same connection.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  To monitor the state of the movement, listen to the [state stream](streamMotionGroupState). The state is published via nats as well. Field `execute` in the `MotionGroupState` indicates whether a movement is ongoing and carries execution details.  Each request has a corresponding acknowledgment response. They signal success or failure of the request. Especially for `PauseMovementResponse`, it does not signal the end of the movement.  Additionally, `MovementError` messages can be sent in case of unexpected errors during the execution, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished.
    * @summary Execute Trajectory
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} controller Unique identifier to address a controller in the cell.
@@ -7599,7 +7599,7 @@ declare const TrajectoryExecutionApiFactory: (configuration?: Configuration, bas
  */
 declare class TrajectoryExecutionApi extends BaseAPI {
   /**
-   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  - `InitializeMovementResponse` is sent to signal the success or failure of the `InitializeMovementRequest`. - Movement responses are streamed after a `StartMovementRequest` successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by `InitializeMovementRequest`. - Standstill response is sent once the movement has finished or has come to a standstill due to a pause. - `PauseMovementResponse` is sent to signal the success of the `PauseMovementRequest`. It does not signal the end of the movement.   End of movement is signaled by Standstill response. - `PlaybackSpeedResponse` is sent to signal the success of the `PlaybackSpeedRequest`. - `MovementError` with error details is sent in case of an unexpected error, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished.
+   * <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time.   Pausing the current movement enables you to send another `InitializeMovementRequest` to execute another trajectory on the same connection.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  To monitor the state of the movement, listen to the [state stream](streamMotionGroupState). The state is published via nats as well. Field `execute` in the `MotionGroupState` indicates whether a movement is ongoing and carries execution details.  Each request has a corresponding acknowledgment response. They signal success or failure of the request. Especially for `PauseMovementResponse`, it does not signal the end of the movement.  Additionally, `MovementError` messages can be sent in case of unexpected errors during the execution, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished.
    * @summary Execute Trajectory
    * @param {string} cell Unique identifier addressing a cell in all API calls.
    * @param {string} controller Unique identifier to address a controller in the cell.

package/dist/v2/index.js

@@ -3215,7 +3215,7 @@ const JoggingApiFactory = function(configuration, basePath, axios) {
 */
 var JoggingApi = class extends BaseAPI {
 	/**
-	* <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. 
+	* <!-- theme: success -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP. The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send `InitializeJoggingRequest` to configure the jogging.  - Sets the robot controller mode to control mode. - Sets rate and coordinate system for the jogging response.  #### 2. Send `JointVelocityRequest` or `TcpVelocityRequest` to start the jogging motion.  - Commands can only be processed in the cycle rate of the controller - Sending commands faster will not increase the responsiveness of the jogging motion, it will lead to dropped commands - It is recommended to couple sending commands with the (state stream)[streamMotionGroupState], which can be subscribed to via nats as well.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with `JointVelocityRequest` or `TcpVelocityRequest`. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - `InitializeJoggingResponse` is sent to signal the success or failure of the `InitializeJoggingRequest`. - Jogging responses are streamed continuously after an `InitializeJoggingRequest` is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - `JoggingErrorResponse` with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the `JoggingResponse`, verify that the robot control is in the desired state, e.g., standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. 
 	* @summary Execute Jogging
 	* @param {string} cell Unique identifier addressing a cell in all API calls. 
 	* @param {string} controller Unique identifier to address a controller in the cell.
@@ -6191,7 +6191,7 @@ const TrajectoryExecutionApiFactory = function(configuration, basePath, axios) {
 */
 var TrajectoryExecutionApi = class extends BaseAPI {
 	/**
-	* <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  - `InitializeMovementResponse` is sent to signal the success or failure of the `InitializeMovementRequest`. - Movement responses are streamed after a `StartMovementRequest` successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by `InitializeMovementRequest`. - Standstill response is sent once the movement has finished or has come to a standstill due to a pause. - `PauseMovementResponse` is sent to signal the success of the `PauseMovementRequest`. It does not signal the end of the movement.   End of movement is signaled by Standstill response. - `PlaybackSpeedResponse` is sent to signal the success of the `PlaybackSpeedRequest`. - `MovementError` with error details is sent in case of an unexpected error, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished. 
+	* <!-- theme: success -->  > Websocket endpoint  Provides execution control over a previously [planned trajectory](planTrajectory). Enables the caller to attach input/output actions to the trajectory.  ### Movement behavior  | Virtual controller | Physical controller | |------------------|-------------------| | Desired joint configurations are commanded to each motion group and **applied immediately** | Move to desired **actual joint configuration**, **if possible** |  ### Concept of location    - The location or path parameter specifies the exact position along a trajectory.   - The location is a scalar value that ranges from 0 to `n`, where `n` denotes the number of motion commands, or trajectory segments, e.g., line, p2p, etc. See [planTrajectory](planTrajectory).   - Each integer value of the location corresponds to one motion command, e.g., 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with `InitializeMovementRequest`. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send `InitializeMovementRequest` to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time.   Pausing the current movement enables you to send another `InitializeMovementRequest` to execute another trajectory on the same connection.  #### 2. Send `StartMovementRequest` to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send `PauseMovementRequest` before the movement has reached its end location. - Change the movement\'s velocity with `PlaybackSpeedRequest` after initializing the movement with `InitializeMovementRequest`.  ### Responses  To monitor the state of the movement, listen to the [state stream](streamMotionGroupState). The state is published via nats as well. Field `execute` in the `MotionGroupState` indicates whether a movement is ongoing and carries execution details.  Each request has a corresponding acknowledgment response. They signal success or failure of the request. Especially for `PauseMovementResponse`, it does not signal the end of the movement.  Additionally, `MovementError` messages can be sent in case of unexpected errors during the execution, e.g., controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending `PauseMovementRequest` and `StartMovementRequest`. - Send `PlaybackSpeedRequest` before `StartMovementRequest` to reduce the velocity of the movement before it starts. - Send `PlaybackSpeedRequest` repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send `PlaybackSpeedRequest` with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending `StartMovementRequest` after the movement has finished. 
 	* @summary Execute Trajectory
 	* @param {string} cell Unique identifier addressing a cell in all API calls. 
 	* @param {string} controller Unique identifier to address a controller in the cell.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wandelbots/nova-api",
-  "version": "25.11.0-dev.29",
+  "version": "25.11.0-dev.30",
   "description": "API Client to interact with Wandelbots Public API.",
   "type": "module",
   "files": [