@wandelbots/nova-api 25.6.0-dev.35 → 25.6.0-dev.37

package/v2/api.ts

@@ -122,7 +122,7 @@ export interface AddTrajectoryError {
  * @type AddTrajectoryErrorData
  * @export
  */
-export type AddTrajectoryErrorData = Collision2 | InconsitentTrajectorySize | InvalidDof | JointLimitExceeded | NanValue | TcpRequired | TorqueExceeded;
+export type AddTrajectoryErrorData = CollisionError | InconsitentTrajectorySize | InvalidDof | JointLimitExceeded | NanValue | TcpRequired | TorqueExceeded;
 
 /**
  * 
@@ -398,6 +398,37 @@ export const CapsuleShapeTypeEnum = {
 
 export type CapsuleShapeTypeEnum = typeof CapsuleShapeTypeEnum[keyof typeof CapsuleShapeTypeEnum];
 
+/**
+ * 
+ * @export
+ * @interface CartesianLimits
+ */
+export interface CartesianLimits {
+    /**
+     * 
+     * @type {number}
+     * @memberof CartesianLimits
+     */
+    'velocity'?: number;
+    /**
+     * 
+     * @type {number}
+     * @memberof CartesianLimits
+     */
+    'acceleration'?: number;
+    /**
+     * 
+     * @type {number}
+     * @memberof CartesianLimits
+     */
+    'orientation_velocity'?: number;
+    /**
+     * 
+     * @type {number}
+     * @memberof CartesianLimits
+     */
+    'orientation_acceleration'?: number;
+}
 /**
  * To create a robot cell, only a valid name is required. Once created, a robot cell provides access to the Wandelbots NOVA foundation services. The configuration can be customized, e.g. robot controllers, also within apps. 
  * @export
@@ -503,19 +534,6 @@ export interface Collision {
      */
     'position_on_b'?: CollisionContact;
 }
-/**
- * 
- * @export
- * @interface Collision2
- */
-export interface Collision2 {
-    /**
-     * 
-     * @type {FeedbackCollision}
-     * @memberof Collision2
-     */
-    'collision'?: FeedbackCollision;
-}
 /**
  * 
  * @export
@@ -535,6 +553,19 @@ export interface CollisionContact {
      */
     'world'?: Array<number>;
 }
+/**
+ * 
+ * @export
+ * @interface CollisionError
+ */
+export interface CollisionError {
+    /**
+     * 
+     * @type {FeedbackCollision}
+     * @memberof CollisionError
+     */
+    'collision'?: FeedbackCollision;
+}
 /**
  * 
  * @export
@@ -959,6 +990,26 @@ export const Direction = {
 export type Direction = typeof Direction[keyof typeof Direction];
 
 
+/**
+ * 
+ * @export
+ * @interface EndOfTrajectory
+ */
+export interface EndOfTrajectory {
+    /**
+     * 
+     * @type {string}
+     * @memberof EndOfTrajectory
+     */
+    'kind': EndOfTrajectoryKindEnum;
+}
+
+export const EndOfTrajectoryKindEnum = {
+    EndOfTrajectory: 'END_OF_TRAJECTORY'
+} as const;
+
+export type EndOfTrajectoryKindEnum = typeof EndOfTrajectoryKindEnum[keyof typeof EndOfTrajectoryKindEnum];
+
 /**
  * 
  * @export
@@ -972,17 +1023,42 @@ export interface Error2 {
      */
     'message': string;
 }
+/**
+ * Details about the state of the motion execution. The details are either for a jogging or a trajectory. If NOVA is not controlling this motion group at the moment, this field is omitted. 
+ * @export
+ * @interface Execute
+ */
+export interface Execute {
+    /**
+     * Commanded joint position of each joint in [rad]. This command was sent in the time step the corresponding state was received. 
+     * @type {Array<number>}
+     * @memberof Execute
+     */
+    'joint_position': Array<number>;
+    /**
+     * 
+     * @type {ExecuteDetails}
+     * @memberof Execute
+     */
+    'details'?: ExecuteDetails;
+}
+/**
+ * @type ExecuteDetails
+ * @export
+ */
+export type ExecuteDetails = { kind: 'JOGGING' } & JoggingDetails | { kind: 'TRAJECTORY' } & TrajectoryDetails;
+
 /**
  * @type ExecuteJoggingRequest
  * @export
  */
-export type ExecuteJoggingRequest = InitializeJoggingRequest | JointVelocityRequest | TcpVelocityRequest;
+export type ExecuteJoggingRequest = InitializeJoggingRequest | JointVelocityRequest | PauseJoggingRequest | TcpVelocityRequest;
 
 /**
  * @type ExecuteJoggingResponse
  * @export
  */
-export type ExecuteJoggingResponse = InitializeJoggingResponse | JoggingErrorResponse | JoggingResponse;
+export type ExecuteJoggingResponse = InitializeJoggingResponse | JointVelocityResponse | MovementErrorResponse | PauseJoggingResponse | TcpVelocityResponse;
 
 /**
  * @type ExecuteTrajectoryRequest
@@ -994,7 +1070,7 @@ export type ExecuteTrajectoryRequest = InitializeMovementRequest | PauseMovement
  * @type ExecuteTrajectoryResponse
  * @export
  */
-export type ExecuteTrajectoryResponse = InitializeMovementResponse | Movement | MovementError | PauseMovementResponse | PlaybackSpeedResponse | Standstill;
+export type ExecuteTrajectoryResponse = InitializeMovementResponse | MovementErrorResponse | PauseMovementResponse | PlaybackSpeedResponse | StartMovementResponse;
 
 /**
  * A datapoint inside external joint stream.
@@ -1613,37 +1689,31 @@ export const InitializeJoggingRequestMessageTypeEnum = {
 export type InitializeJoggingRequestMessageTypeEnum = typeof InitializeJoggingRequestMessageTypeEnum[keyof typeof InitializeJoggingRequestMessageTypeEnum];
 
 /**
- * Response to an InitializeJoggingRequest.
+ * Acknowledgment to an InitializeJoggingRequest. 
  * @export
  * @interface InitializeJoggingResponse
  */
 export interface InitializeJoggingResponse {
     /**
-     * 
-     * @type {InitializeJoggingResponseInitResponse}
+     * Error message in case of invalid InitializeJoggingRequest.
+     * @type {string}
      * @memberof InitializeJoggingResponse
      */
-    'init_response': InitializeJoggingResponseInitResponse;
-}
-/**
- * 
- * @export
- * @interface InitializeJoggingResponseInitResponse
- */
-export interface InitializeJoggingResponseInitResponse {
-    /**
-     * Indicates if the jogging control is ready for execution. 
-     * @type {boolean}
-     * @memberof InitializeJoggingResponseInitResponse
-     */
-    'succeeded': boolean;
+    'message'?: string;
     /**
-     * Error message in case of invalid InitializeMovementRequest.
+     * 
      * @type {string}
-     * @memberof InitializeJoggingResponseInitResponse
+     * @memberof InitializeJoggingResponse
      */
-    'error_message'?: string;
+    'kind': InitializeJoggingResponseKindEnum;
 }
+
+export const InitializeJoggingResponseKindEnum = {
+    InitializeReceived: 'INITIALIZE_RECEIVED'
+} as const;
+
+export type InitializeJoggingResponseKindEnum = typeof InitializeJoggingResponseKindEnum[keyof typeof InitializeJoggingResponseKindEnum];
+
 /**
  * Sets up connection by locking a trajectory for execution. The robot controller mode is set to control mode. ATTENTION: This request has to be sent before any StartMovementRequest is sent.            If initializing the movement was successful, no further movements can be initialized. To execute another trajectory, another connection has to be established. 
  * @export
@@ -1702,31 +1772,31 @@ export type InitializeMovementRequestTrajectory = { message_type: 'TrajectoryDat
  */
 export interface InitializeMovementResponse {
     /**
-     * 
-     * @type {InitializeMovementResponseInitResponse}
+     * Error message in case of invalid InitializeMovementRequest.
+     * @type {string}
      * @memberof InitializeMovementResponse
      */
-    'init_response': InitializeMovementResponseInitResponse;
-}
-/**
- * 
- * @export
- * @interface InitializeMovementResponseInitResponse
- */
-export interface InitializeMovementResponseInitResponse {
+    'message'?: string;
     /**
-     * Indicates if the trajectory was successfully locked and is ready for execution by sending a StartMovementRequest. Send PlaybackSpeedRequest to override the planned velocity. 
-     * @type {boolean}
-     * @memberof InitializeMovementResponseInitResponse
+     * Error can occur if joint trajectory was added by [InitializeMovementRequest](InitializeMovementRequest) and the trajectory is invalid. 
+     * @type {AddTrajectoryError}
+     * @memberof InitializeMovementResponse
      */
-    'succeeded': boolean;
+    'add_trajectory_error'?: AddTrajectoryError;
     /**
-     * Error message in case of invalid InitializeMovementRequest.
+     * 
      * @type {string}
-     * @memberof InitializeMovementResponseInitResponse
+     * @memberof InitializeMovementResponse
      */
-    'error_message'?: string;
+    'kind': InitializeMovementResponseKindEnum;
 }
+
+export const InitializeMovementResponseKindEnum = {
+    InitializeReceived: 'INITIALIZE_RECEIVED'
+} as const;
+
+export type InitializeMovementResponseKindEnum = typeof InitializeMovementResponseKindEnum[keyof typeof InitializeMovementResponseKindEnum];
+
 /**
  * Value of an input/output with integer representation.  > The integral value is transmitted as a string to avoid precision loss during conversion to JSON. > We recommend to use int64 in your implementation. If you want to interact with int64 in numbers, > JS bigint libraries can help you to parse the string into an integral value. 
  * @export
@@ -1817,10 +1887,10 @@ export interface InverseKinematicsRequest {
     'mounting'?: Pose;
     /**
      * Joint position limits in [rad], indexed starting from base. 
-     * @type {Array<PlanningLimitsLimitRange>}
+     * @type {Array<LimitRange>}
      * @memberof InverseKinematicsRequest
      */
-    'joint_position_limits'?: Array<PlanningLimitsLimitRange>;
+    'joint_position_limits'?: Array<LimitRange>;
     /**
      * Collision scenes to be respected by the motion planner. Each contains the single motion group which is planned for. Scenes are checked individually along the trajectory and independently of other scenes. To respect the safety zones of the controller, fetch the safety zones, link and tool shapes from the controller and add one scene made up of those. To respect the safety zones of the controller and check for collision: 1. Fetch the safety zones, link and tool shapes from the controller. 2. Add the fetched zones, links and tools to a scene. 3. Create other scenes from your own 3D data as needed. 4. Execute this endpoint. 5. The response highlights the scenes in which a collision was detected by key. 
      * @type {{ [key: string]: SingleMotionGroupCollisionScene; }}
@@ -1842,172 +1912,80 @@ export interface InverseKinematicsResponse {
     'joints': Array<Array<Array<number>>>;
 }
 /**
- * Response signalling an error during jogging execution. This response is sent in case of an unexpected error, e.g. controller disconnects. 
- * @export
- * @interface JoggingErrorResponse
- */
-export interface JoggingErrorResponse {
-    /**
-     * 
-     * @type {JoggingErrorResponseError}
-     * @memberof JoggingErrorResponse
-     */
-    'error': JoggingErrorResponseError;
-}
-/**
- * 
- * @export
- * @interface JoggingErrorResponseError
- */
-export interface JoggingErrorResponseError {
-    /**
-     * Error description.
-     * @type {string}
-     * @memberof JoggingErrorResponseError
-     */
-    'error_message': string;
-}
-/**
- * 
+ * State of jogging execution. This state is sent during jogging movement, response-rate closest to the nearest multiple of controller step-rate but not exceeding the configured rate. The jogging state can be one of the following: - RUNNING: Jogging is active. - PAUSED_BY_USER: User has paused jogging. - PAUSED_NEAR_JOINT_LIMIT: Jogging was paused because a joint is is near its limit. - PAUSED_NEAR_COLLISION: Jogging was paused because the motion group neared a collision. - PAUSED_ON_IO: Jogging was paused because of an I/O event. 
  * @export
- * @interface JoggingPausedCollision
+ * @interface JoggingDetails
  */
-export interface JoggingPausedCollision {
+export interface JoggingDetails {
     /**
      * 
-     * @type {JoggingPausedCollisionPausedNearCollision}
-     * @memberof JoggingPausedCollision
+     * @type {JoggingDetailsState}
+     * @memberof JoggingDetails
      */
-    'paused_near_collision': JoggingPausedCollisionPausedNearCollision;
-}
-/**
- * 
- * @export
- * @interface JoggingPausedCollisionPausedNearCollision
- */
-export interface JoggingPausedCollisionPausedNearCollision {
+    'state': JoggingDetailsState;
     /**
      * 
      * @type {string}
-     * @memberof JoggingPausedCollisionPausedNearCollision
-     */
-    'description'?: string;
-}
-/**
- * 
- * @export
- * @interface JoggingPausedJointLimit
- */
-export interface JoggingPausedJointLimit {
-    /**
-     * 
-     * @type {JoggingPausedJointLimitPausedNearJointLimit}
-     * @memberof JoggingPausedJointLimit
-     */
-    'paused_near_joint_limit': JoggingPausedJointLimitPausedNearJointLimit;
-}
-/**
- * 
- * @export
- * @interface JoggingPausedJointLimitPausedNearJointLimit
- */
-export interface JoggingPausedJointLimitPausedNearJointLimit {
-    /**
-     * 
-     * @type {Array<number>}
-     * @memberof JoggingPausedJointLimitPausedNearJointLimit
+     * @memberof JoggingDetails
      */
-    'joint_indices'?: Array<number>;
+    'kind': JoggingDetailsKindEnum;
 }
+
+export const JoggingDetailsKindEnum = {
+    Jogging: 'JOGGING'
+} as const;
+
+export type JoggingDetailsKindEnum = typeof JoggingDetailsKindEnum[keyof typeof JoggingDetailsKindEnum];
+
 /**
- * 
+ * @type JoggingDetailsState
  * @export
- * @interface JoggingPausedOnIO
  */
-export interface JoggingPausedOnIO {
-    /**
-     * 
-     * @type {object}
-     * @memberof JoggingPausedOnIO
-     */
-    'paused_on_io': object;
-}
+export type JoggingDetailsState = PausedByUser | PausedNearCollision | PausedNearJointLimit | PausedOnIO | Running;
+
 /**
  * 
  * @export
- * @interface JoggingPausedUserRequest
- */
-export interface JoggingPausedUserRequest {
-    /**
-     * 
-     * @type {object}
-     * @memberof JoggingPausedUserRequest
-     */
-    'paused_by_user_request': object;
-}
-/**
- * Sent during jogging movement, response-rate closest to the nearest multiple of controller step-rate but not exceeding the configured rate. 
- * @export
- * @interface JoggingResponse
+ * @interface JointLimitExceeded
  */
-export interface JoggingResponse {
+export interface JointLimitExceeded {
     /**
      * 
-     * @type {JoggingResponseJogging}
-     * @memberof JoggingResponse
+     * @type {FeedbackJointLimitExceeded}
+     * @memberof JointLimitExceeded
      */
-    'jogging': JoggingResponseJogging;
+    'joint_limit_exceeded'?: FeedbackJointLimitExceeded;
 }
 /**
  * 
  * @export
- * @interface JoggingResponseJogging
+ * @interface JointLimits
  */
-export interface JoggingResponseJogging {
+export interface JointLimits {
     /**
      * 
-     * @type {JoggingState}
-     * @memberof JoggingResponseJogging
+     * @type {LimitRange}
+     * @memberof JointLimits
      */
-    'jogging_state': JoggingState;
+    'position'?: LimitRange;
     /**
      * 
-     * @type {RobotControllerState}
-     * @memberof JoggingResponseJogging
+     * @type {number}
+     * @memberof JointLimits
      */
-    'robot_controller_state': RobotControllerState;
-}
-/**
- * 
- * @export
- * @interface JoggingRunning
- */
-export interface JoggingRunning {
+    'velocity'?: number;
     /**
      * 
-     * @type {object}
-     * @memberof JoggingRunning
+     * @type {number}
+     * @memberof JointLimits
      */
-    'running': object;
-}
-/**
- * @type JoggingState
- * @export
- */
-export type JoggingState = JoggingPausedCollision | JoggingPausedJointLimit | JoggingPausedOnIO | JoggingPausedUserRequest | JoggingRunning;
-
-/**
- * 
- * @export
- * @interface JointLimitExceeded
- */
-export interface JointLimitExceeded {
+    'acceleration'?: number;
     /**
      * 
-     * @type {FeedbackJointLimitExceeded}
-     * @memberof JointLimitExceeded
+     * @type {number}
+     * @memberof JointLimits
      */
-    'joint_limit_exceeded'?: FeedbackJointLimitExceeded;
+    'torque'?: number;
 }
 /**
  * 
@@ -2060,6 +2038,32 @@ export const JointVelocityRequestMessageTypeEnum = {
 
 export type JointVelocityRequestMessageTypeEnum = typeof JointVelocityRequestMessageTypeEnum[keyof typeof JointVelocityRequestMessageTypeEnum];
 
+/**
+ * Acknowledgment to a JointVelocityRequest. 
+ * @export
+ * @interface JointVelocityResponse
+ */
+export interface JointVelocityResponse {
+    /**
+     * Error message in case of invalid JointVelocityRequest.
+     * @type {string}
+     * @memberof JointVelocityResponse
+     */
+    'message'?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof JointVelocityResponse
+     */
+    'kind': JointVelocityResponseKindEnum;
+}
+
+export const JointVelocityResponseKindEnum = {
+    JointVelocityReceived: 'JOINT_VELOCITY_RECEIVED'
+} as const;
+
+export type JointVelocityResponseKindEnum = typeof JointVelocityResponseKindEnum[keyof typeof JointVelocityResponseKindEnum];
+
 /**
  * This structure describes a set of joint values of a motion group.  We call a set of joint values describing the current position in joint space of a motion group a \"joint position\". Joint position was chosen as the term to be consistent with the terms \"joint velocity\" and \"joint acceleration\".  `joints` must have as many entries as the motion group\'s degrees of freedom to be valid.  Float precision is the default. 
  * @export
@@ -2235,6 +2239,75 @@ export const LicenseStatusEnum = {
 export type LicenseStatusEnum = typeof LicenseStatusEnum[keyof typeof LicenseStatusEnum];
 
 
+/**
+ * 
+ * @export
+ * @interface LimitConfig
+ */
+export interface LimitConfig {
+    /**
+     * 
+     * @type {LimitSet}
+     * @memberof LimitConfig
+     */
+    'physical_limits'?: LimitSet;
+    /**
+     * 
+     * @type {OperationLimits}
+     * @memberof LimitConfig
+     */
+    'operation_limits'?: OperationLimits;
+}
+/**
+ * The upper_limit must be greater then the lower_limit.
+ * @export
+ * @interface LimitRange
+ */
+export interface LimitRange {
+    /**
+     * 
+     * @type {number}
+     * @memberof LimitRange
+     */
+    'lower_limit'?: number;
+    /**
+     * 
+     * @type {number}
+     * @memberof LimitRange
+     */
+    'upper_limit'?: number;
+}
+/**
+ * 
+ * @export
+ * @interface LimitSet
+ */
+export interface LimitSet {
+    /**
+     * 
+     * @type {Array<JointLimits>}
+     * @memberof LimitSet
+     */
+    'joints'?: Array<JointLimits>;
+    /**
+     * 
+     * @type {CartesianLimits}
+     * @memberof LimitSet
+     */
+    'tcp'?: CartesianLimits;
+    /**
+     * 
+     * @type {CartesianLimits}
+     * @memberof LimitSet
+     */
+    'elbow'?: CartesianLimits;
+    /**
+     * 
+     * @type {CartesianLimits}
+     * @memberof LimitSet
+     */
+    'flange'?: CartesianLimits;
+}
 /**
  * If a limit is not set, the default value will be used. 
  * @export
@@ -2437,10 +2510,10 @@ export interface MotionGroupDescription {
     'safety_tool_colliders'?: { [key: string]: { [key: string]: Collider; }; };
     /**
      * 
-     * @type {PlanningLimits}
+     * @type {LimitConfig}
      * @memberof MotionGroupDescription
      */
-    'global_limits': PlanningLimits;
+    'global_limits': LimitConfig;
     /**
      * Maps a payload name to its configuration. Key must be a payload identifier. Values are payload objects. 
      * @type {{ [key: string]: Payload; }}
@@ -2530,17 +2603,17 @@ export interface MotionGroupJoints {
     'torques'?: Array<number>;
 }
 /**
- * 
+ * Presents the current state of the motion group.
  * @export
  * @interface MotionGroupState
  */
 export interface MotionGroupState {
     /**
-     * Timestamp indicating when the represented information was received from the robot controller.
+     * Timestamp for when data was received from the robot controller.
      * @type {string}
      * @memberof MotionGroupState
      */
-    'timestamp'?: string;
+    'timestamp': string;
     /**
      * Sequence number of the controller state. It starts with 0 upon establishing the connection with a physical controller. The sequence number is reset when the connection to the physical controller is closed and re-established. 
      * @type {number}
@@ -2572,59 +2645,59 @@ export interface MotionGroupState {
      */
     'joint_limit_reached': MotionGroupStateJointLimitReached;
     /**
-     * Current joint velocity of each joint in [rad/s] 
-     * @type {Joints}
-     * @memberof MotionGroupState
-     */
-    'joint_velocity': Joints;
-    /**
-     * Current joint torque of each joint in [Nm]. Is only available if the robot controller supports it (e.g. available for UR Controllers). 
+     * Current joint torque of each joint in [Nm]. Is only available if the robot controller supports it, e.g. available for UR controllers. 
      * @type {Joints}
      * @memberof MotionGroupState
      */
     'joint_torque'?: Joints;
     /**
-     * Current Current at TCP in [A]. Is only available if the robot controller supports it, e.g. available for UR Controllers. 
+     * Current at TCP in [A]. Is only available if the robot controller supports it, e.g. available for UR controllers. 
      * @type {Joints}
      * @memberof MotionGroupState
      */
     'joint_current'?: Joints;
     /**
-     * Pose of the Flange (last point of the motion group before the endeffector starts). Positions are in [mm]. Oriantations are in [rad]. The pose is relative to the response_coordinate_system that is specified in the request. For robot arms a flange pose is always returned, for positioners the flange might not be available, depending on the model. 
+     * Pose of the flange. Positions are in [mm]. Oriantations are in [rad]. The pose is relative to the response_coordinate_system specified in the request. For robot arms a flange pose is always returned, for positioners the flange might not be available, depending on the model. 
      * @type {Pose}
      * @memberof MotionGroupState
      */
     'flange_pose'?: Pose;
     /**
-     * Unique identifier addressing the TCP currently set. 
+     * Unique identifier addressing the active TCP. Might not be returned for positioners as some do not support TCPs, depending on the model. 
      * @type {string}
      * @memberof MotionGroupState
      */
-    'tcp': string;
+    'tcp'?: string;
     /**
-     * Pose of the TCP currently selected on the robot control panel. Positions are in [mm]. Oriantations are in [rad]. The pose is relative to the response_coordinate_system that is specified in the request. 
+     * Pose of the TCP selected on the robot control panel. Positions are in [mm]. Oriantations are in [rad]. The pose is relative to the response_coordinate_system specified in the request. Might not be returned for positioners as some do not support TCPs, depending on the model. 
      * @type {Pose}
      * @memberof MotionGroupState
      */
-    'tcp_pose': Pose;
+    'tcp_pose'?: Pose;
     /**
-     * Current velocity at TCP in [mm/s]. If `tcp` is not specified, the velocity at the flange is returned. The velocity is relative to the response_coordinate_system specified in the request. 
-     * @type {MotionVector}
+     * Unique identifier addressing the reference coordinate system of the cartesian data. Might not be returned for positioners as some do not support TCPs, depending on the model. Default: world coordinate system of corresponding controller. 
+     * @type {string}
      * @memberof MotionGroupState
      */
-    'tcp_velocity': MotionVector;
+    'coordinate_system'?: string;
     /**
-     * Unique identifier addressing the reference coordinate system of the cartesian data. Default is the world coordinate system of corresponding controller. 
+     * Unique identifier addressing the active payload. Only fetchable via GET endpoint, not available in WebSocket. 
      * @type {string}
      * @memberof MotionGroupState
      */
-    'coordinate_system': string;
+    'payload'?: string;
     /**
-     * Unique identifier addressing the Payload currently set. Only fetchable via GET endpoint, not available in WebSocket. 
-     * @type {string}
+     * Indicates whether the motion group is in standstill. Convenience: Signals that NOVA treats measured joint velocities as 0. 
+     * @type {boolean}
      * @memberof MotionGroupState
      */
-    'payload'?: string;
+    'standstill': boolean;
+    /**
+     * Data that was commanded to the motion group. Includes additional data on NOVA\'s execution components for executing trajectories and jogging. This is a convenience field to indicate the last command sent to the motion group. It is not available in all cases, e.g. if the motion group is not moved by NOVA. 
+     * @type {Execute}
+     * @memberof MotionGroupState
+     */
+    'execute'?: Execute;
 }
 /**
  * Indicates which joint of the motion group is in a limit. If a joint is in its limit, only this joint can be moved. Movements that affect any other joints are not executed. 
@@ -2639,97 +2712,6 @@ export interface MotionGroupStateJointLimitReached {
      */
     'limit_reached': Array<boolean>;
 }
-/**
- * Presents the current state of the motion group.
- * @export
- * @interface MotionGroupStateWithoutPayload
- */
-export interface MotionGroupStateWithoutPayload {
-    /**
-     * Timestamp indicating when the represented information was received from the robot controller.
-     * @type {string}
-     * @memberof MotionGroupStateWithoutPayload
-     */
-    'timestamp'?: string;
-    /**
-     * Sequence number of the controller state. It starts with 0 upon establishing the connection with a physical controller. The sequence number is reset when the connection to the physical controller is closed and re-established. 
-     * @type {number}
-     * @memberof MotionGroupStateWithoutPayload
-     */
-    'sequence_number': number;
-    /**
-     * Identifier of the motion group.
-     * @type {string}
-     * @memberof MotionGroupStateWithoutPayload
-     */
-    'motion_group': string;
-    /**
-     * Convenience: Identifier of the robot controller the motion group is attached to.
-     * @type {string}
-     * @memberof MotionGroupStateWithoutPayload
-     */
-    'controller': string;
-    /**
-     * Current joint position of each joint in [rad] 
-     * @type {Joints}
-     * @memberof MotionGroupStateWithoutPayload
-     */
-    'joint_position': Joints;
-    /**
-     * Indicates whether the joint is in a limit for all joints of the motion group. 
-     * @type {MotionGroupStateJointLimitReached}
-     * @memberof MotionGroupStateWithoutPayload
-     */
-    'joint_limit_reached': MotionGroupStateJointLimitReached;
-    /**
-     * Current joint velocity of each joint in [rad/s] 
-     * @type {Joints}
-     * @memberof MotionGroupStateWithoutPayload
-     */
-    'joint_velocity': Joints;
-    /**
-     * Current joint torque of each joint in [Nm]. Is only available if the robot controller supports it (e.g. available for UR Controllers). 
-     * @type {Joints}
-     * @memberof MotionGroupStateWithoutPayload
-     */
-    'joint_torque'?: Joints;
-    /**
-     * Current Current at TCP in [A]. Is only available if the robot controller supports it, e.g. available for UR Controllers. 
-     * @type {Joints}
-     * @memberof MotionGroupStateWithoutPayload
-     */
-    'joint_current'?: Joints;
-    /**
-     * Pose of the Flange (last point of the motion group before the endeffector starts). Positions are in [mm]. Oriantations are in [rad]. The pose is relative to the response_coordinate_system that is specified in the request. For robot arms a flange pose is always returned, for positioners the flange might not be available, depending on the model. 
-     * @type {Pose}
-     * @memberof MotionGroupStateWithoutPayload
-     */
-    'flange_pose'?: Pose;
-    /**
-     * Unique identifier addressing the TCP currently set. 
-     * @type {string}
-     * @memberof MotionGroupStateWithoutPayload
-     */
-    'tcp': string;
-    /**
-     * Pose of the TCP currently selected on the robot control panel. Positions are in [mm]. Oriantations are in [rad]. The pose is relative to the response_coordinate_system that is specified in the request. 
-     * @type {Pose}
-     * @memberof MotionGroupStateWithoutPayload
-     */
-    'tcp_pose': Pose;
-    /**
-     * Current velocity at TCP in [mm/s]. If `tcp` is not specified, the velocity at the flange is returned. The velocity is relative to the response_coordinate_system specified in the request. 
-     * @type {MotionVector}
-     * @memberof MotionGroupStateWithoutPayload
-     */
-    'tcp_velocity': MotionVector;
-    /**
-     * Unique identifier addressing the reference coordinate system of the cartesian data. Default is the world coordinate system of corresponding controller. 
-     * @type {string}
-     * @memberof MotionGroupStateWithoutPayload
-     */
-    'coordinate_system': string;
-}
 /**
  * Collection of information on the current state of the robot.
  * @export
@@ -2756,94 +2738,31 @@ export interface MotionState {
     'state': RobotState;
 }
 /**
- * 
+ * Error message in case an error occurs during movement execution. 
  * @export
- * @interface MotionVector
+ * @interface MovementErrorResponse
  */
-export interface MotionVector {
-    /**
-     * A three-dimensional vector [x, y, z] with double precision. 
-     * @type {Array<number>}
-     * @memberof MotionVector
-     */
-    'linear'?: Array<number>;
+export interface MovementErrorResponse {
     /**
-     * A three-dimensional vector [x, y, z] with double precision. 
-     * @type {Array<number>}
-     * @memberof MotionVector
-     */
-    'angular'?: Array<number>;
-    /**
-     * optional, unique name of base coordinate system, if empty world is used
+     * Detailed error message describing the issue encountered during movement execution.
      * @type {string}
-     * @memberof MotionVector
+     * @memberof MovementErrorResponse
      */
-    'coordinate_system'?: string;
-}
-/**
- * Sent during trajectory movement, response-rate closest to the nearest multiple of controller step-rate but not exceeding the configured rate. 
- * @export
- * @interface Movement
- */
-export interface Movement {
-    /**
-     * 
-     * @type {MovementMovement}
-     * @memberof Movement
-     */
-    'movement': MovementMovement;
-}
-/**
- * Response signalling an error during trajectory execution. This response is sent in case of an unexpected error , e.g. controller disconnects. The error details are described in the error_message field. 
- * @export
- * @interface MovementError
- */
-export interface MovementError {
+    'message': string;
     /**
      * 
-     * @type {MovementErrorError}
-     * @memberof MovementError
-     */
-    'error': MovementErrorError;
-}
-/**
- * 
- * @export
- * @interface MovementErrorError
- */
-export interface MovementErrorError {
-    /**
-     * Human-readable error details that describes the error. 
      * @type {string}
-     * @memberof MovementErrorError
-     */
-    'error_message': string;
-}
-/**
- * 
- * @export
- * @interface MovementMovement
- */
-export interface MovementMovement {
-    /**
-     * Remaining time in milliseconds (ms) to reach the end of the motion.
-     * @type {number}
-     * @memberof MovementMovement
-     */
-    'time_to_end': number;
-    /**
-     * Current location of motion group on the trajectory.
-     * @type {number}
-     * @memberof MovementMovement
-     */
-    'current_location': number;
-    /**
-     * Current state of the robot controller and moving motion group.
-     * @type {RobotControllerState}
-     * @memberof MovementMovement
+     * @memberof MovementErrorResponse
      */
-    'state': RobotControllerState;
+    'kind': MovementErrorResponseKindEnum;
 }
+
+export const MovementErrorResponseKindEnum = {
+    Error: 'ERROR'
+} as const;
+
+export type MovementErrorResponseKindEnum = typeof MovementErrorResponseKindEnum[keyof typeof MovementErrorResponseKindEnum];
+
 /**
  * 
  * @export
@@ -2899,6 +2818,37 @@ export const OperatingState = {
 export type OperatingState = typeof OperatingState[keyof typeof OperatingState];
 
 
+/**
+ * 
+ * @export
+ * @interface OperationLimits
+ */
+export interface OperationLimits {
+    /**
+     * 
+     * @type {LimitSet}
+     * @memberof OperationLimits
+     */
+    'auto_limits'?: LimitSet;
+    /**
+     * 
+     * @type {LimitSet}
+     * @memberof OperationLimits
+     */
+    'manual_limits'?: LimitSet;
+    /**
+     * 
+     * @type {LimitSet}
+     * @memberof OperationLimits
+     */
+    'manual_t1_limits'?: LimitSet;
+    /**
+     * 
+     * @type {LimitSet}
+     * @memberof OperationLimits
+     */
+    'manual_t2_limits'?: LimitSet;
+}
 /**
  * Current operation mode of the configured robot controller. Operation modes in which the attached motion groups can be moved are: - OPERATION_MODE_MANUAL (if enabling switch is pressed) - OPERATION_MODE_MANUAL_T1 (if enabling switch is pressed) - OPERATION_MODE_MANUAL_T2 (if enabling switch is pressed) - OPERATION_MODE_AUTO (without needing to press enabling switch) All other modes are considered as non-operational. 
  * @export
@@ -3095,6 +3045,52 @@ export const PathLinePathDefinitionNameEnum = {
 
 export type PathLinePathDefinitionNameEnum = typeof PathLinePathDefinitionNameEnum[keyof typeof PathLinePathDefinitionNameEnum];
 
+/**
+ * Request to pause jogging. If successful, `execute` jogging state in [MotionGroupState](MotionGroupState.yaml) is set to `PAUSED_BY_USER`. 
+ * @export
+ * @interface PauseJoggingRequest
+ */
+export interface PauseJoggingRequest {
+    /**
+     * Type specifier for server, set automatically. 
+     * @type {string}
+     * @memberof PauseJoggingRequest
+     */
+    'message_type'?: PauseJoggingRequestMessageTypeEnum;
+}
+
+export const PauseJoggingRequestMessageTypeEnum = {
+    PauseJoggingRequest: 'PauseJoggingRequest'
+} as const;
+
+export type PauseJoggingRequestMessageTypeEnum = typeof PauseJoggingRequestMessageTypeEnum[keyof typeof PauseJoggingRequestMessageTypeEnum];
+
+/**
+ * Acknowledgment to a PauseJoggingRequest. 
+ * @export
+ * @interface PauseJoggingResponse
+ */
+export interface PauseJoggingResponse {
+    /**
+     * Error message in case of invalid PauseJoggingRequest.
+     * @type {string}
+     * @memberof PauseJoggingResponse
+     */
+    'message'?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof PauseJoggingResponse
+     */
+    'kind': PauseJoggingResponseKindEnum;
+}
+
+export const PauseJoggingResponseKindEnum = {
+    PauseReceived: 'PAUSE_RECEIVED'
+} as const;
+
+export type PauseJoggingResponseKindEnum = typeof PauseJoggingResponseKindEnum[keyof typeof PauseJoggingResponseKindEnum];
+
 /**
  * Request to pause the movement execution. Movement pauses as soon as a [Standstill](Standstill.yaml) is sent back to the client. Resume movement with StartMovementRequest. 
  * @export
@@ -3107,12 +3103,6 @@ export interface PauseMovementRequest {
      * @memberof PauseMovementRequest
      */
     'message_type'?: PauseMovementRequestMessageTypeEnum;
-    /**
-     * Defaults to `true`. Set to true to get a response signalling successful initiation to pause the movement. 
-     * @type {boolean}
-     * @memberof PauseMovementRequest
-     */
-    'send_response'?: boolean;
 }
 
 export const PauseMovementRequestMessageTypeEnum = {
@@ -3122,37 +3112,31 @@ export const PauseMovementRequestMessageTypeEnum = {
 export type PauseMovementRequestMessageTypeEnum = typeof PauseMovementRequestMessageTypeEnum[keyof typeof PauseMovementRequestMessageTypeEnum];
 
 /**
- * Response for PauseMovementRequest message. ATTENTION: No confirmation that the movement was paused. Confirmation that the PauseMovementRequest was received and is processed.            End of movement execution is signalled by [StillstandResponse](StillstandResponse). 
+ * Acknowledgment for PauseMovementRequest message. ATTENTION: No confirmation that the movement was paused. Confirmation that the PauseMovementRequest was received and is processed.            End of movement execution is signalled by [StillstandResponse](StillstandResponse). 
  * @export
  * @interface PauseMovementResponse
  */
 export interface PauseMovementResponse {
     /**
-     * 
-     * @type {PauseMovementResponsePauseResponse}
+     * Error message in case of invalid PauseMovementResquest.
+     * @type {string}
      * @memberof PauseMovementResponse
      */
-    'pause_response': PauseMovementResponsePauseResponse;
-}
-/**
- * 
- * @export
- * @interface PauseMovementResponsePauseResponse
- */
-export interface PauseMovementResponsePauseResponse {
-    /**
-     * Indicates if PauseMovementRequest can be executed.
-     * @type {boolean}
-     * @memberof PauseMovementResponsePauseResponse
-     */
-    'succeeded': boolean;
+    'message'?: string;
     /**
-     * Error message in case of invalid PauseMovementRequest or failure while claiming motion. 
+     * 
      * @type {string}
-     * @memberof PauseMovementResponsePauseResponse
+     * @memberof PauseMovementResponse
      */
-    'error_message'?: string;
+    'kind': PauseMovementResponseKindEnum;
 }
+
+export const PauseMovementResponseKindEnum = {
+    PauseReceived: 'PAUSE_RECEIVED'
+} as const;
+
+export type PauseMovementResponseKindEnum = typeof PauseMovementResponseKindEnum[keyof typeof PauseMovementResponseKindEnum];
+
 /**
  * Defines an input/output that the motion will be paused for. The motion will stop gracefully on path.
  * @export
@@ -3174,6 +3158,118 @@ export interface PauseOnIO {
 }
 
 
+/**
+ * 
+ * @export
+ * @interface PausedByRequest
+ */
+export interface PausedByRequest {
+    /**
+     * 
+     * @type {string}
+     * @memberof PausedByRequest
+     */
+    'kind': PausedByRequestKindEnum;
+}
+
+export const PausedByRequestKindEnum = {
+    PausedByUser: 'PAUSED_BY_USER'
+} as const;
+
+export type PausedByRequestKindEnum = typeof PausedByRequestKindEnum[keyof typeof PausedByRequestKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface PausedByUser
+ */
+export interface PausedByUser {
+    /**
+     * 
+     * @type {string}
+     * @memberof PausedByUser
+     */
+    'kind': PausedByUserKindEnum;
+}
+
+export const PausedByUserKindEnum = {
+    PausedByUser: 'PAUSED_BY_USER'
+} as const;
+
+export type PausedByUserKindEnum = typeof PausedByUserKindEnum[keyof typeof PausedByUserKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface PausedNearCollision
+ */
+export interface PausedNearCollision {
+    /**
+     * 
+     * @type {string}
+     * @memberof PausedNearCollision
+     */
+    'kind': PausedNearCollisionKindEnum;
+    /**
+     * 
+     * @type {string}
+     * @memberof PausedNearCollision
+     */
+    'description': string;
+}
+
+export const PausedNearCollisionKindEnum = {
+    PausedNearCollision: 'PAUSED_NEAR_COLLISION'
+} as const;
+
+export type PausedNearCollisionKindEnum = typeof PausedNearCollisionKindEnum[keyof typeof PausedNearCollisionKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface PausedNearJointLimit
+ */
+export interface PausedNearJointLimit {
+    /**
+     * 
+     * @type {string}
+     * @memberof PausedNearJointLimit
+     */
+    'kind': PausedNearJointLimitKindEnum;
+    /**
+     * 
+     * @type {Array<number>}
+     * @memberof PausedNearJointLimit
+     */
+    'joint_indices': Array<number>;
+}
+
+export const PausedNearJointLimitKindEnum = {
+    PausedNearJointLimit: 'PAUSED_NEAR_JOINT_LIMIT'
+} as const;
+
+export type PausedNearJointLimitKindEnum = typeof PausedNearJointLimitKindEnum[keyof typeof PausedNearJointLimitKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface PausedOnIO
+ */
+export interface PausedOnIO {
+    /**
+     * 
+     * @type {string}
+     * @memberof PausedOnIO
+     */
+    'kind': PausedOnIOKindEnum;
+}
+
+export const PausedOnIOKindEnum = {
+    PausedOnIo: 'PAUSED_ON_IO'
+} as const;
+
+export type PausedOnIOKindEnum = typeof PausedOnIOKindEnum[keyof typeof PausedOnIOKindEnum];
+
 /**
  * 
  * @export
@@ -3300,104 +3396,6 @@ export const PlaneShapeTypeEnum = {
 
 export type PlaneShapeTypeEnum = typeof PlaneShapeTypeEnum[keyof typeof PlaneShapeTypeEnum];
 
-/**
- * All known joint and cartesian limits of a motion-group. Used for motion planning.
- * @export
- * @interface PlanningLimits
- */
-export interface PlanningLimits {
-    /**
-     * Joint position limits in [rad], indexed starting from base. 
-     * @type {Array<PlanningLimitsLimitRange>}
-     * @memberof PlanningLimits
-     */
-    'joint_position_limits'?: Array<PlanningLimitsLimitRange>;
-    /**
-     * Maximum allowed velocity for joints in [rad/s or mm/s] of the safety setup, starting at base. 
-     * @type {Array<number>}
-     * @memberof PlanningLimits
-     */
-    'joint_velocity_limits'?: Array<number>;
-    /**
-     * Maximum allowed acceleration for joints in [rad/s^2 or mm/s^2] of the safety setup, starting at base. 
-     * @type {Array<number>}
-     * @memberof PlanningLimits
-     */
-    'joint_acceleration_limits'?: Array<number>;
-    /**
-     * Maximum allowed torque for joints in [Nm or N] of the safety setup, starting at base. 
-     * @type {Array<number>}
-     * @memberof PlanningLimits
-     */
-    'joint_torque_limits'?: Array<number>;
-    /**
-     * At maximum one dimensional velocity in [mm/s] at TCP allowed. 
-     * @type {number}
-     * @memberof PlanningLimits
-     */
-    'tcp_velocity_limit'?: number;
-    /**
-     * At maximum one dimensional acceleration in [mm/s^2] at TCP allowed. 
-     * @type {number}
-     * @memberof PlanningLimits
-     */
-    'tcp_acceleration_limit'?: number;
-    /**
-     * At maximum one dimensional orientation velocity in [rad/s] at TCP allowed. 
-     * @type {number}
-     * @memberof PlanningLimits
-     */
-    'tcp_orientation_velocity_limit'?: number;
-    /**
-     * At maximum one dimensional orientation acceleration in [rad/s^2] at TCP allowed. 
-     * @type {number}
-     * @memberof PlanningLimits
-     */
-    'tcp_orientation_acceleration_limit'?: number;
-    /**
-     * At maximum one dimensional force in [N] at TCP allowed. 
-     * @type {number}
-     * @memberof PlanningLimits
-     */
-    'tcp_force_limit'?: number;
-    /**
-     * At maximum one dimensional velocity in [mm/s] at the elbow allowed. 
-     * @type {number}
-     * @memberof PlanningLimits
-     */
-    'elbow_velocity_limit'?: number;
-    /**
-     * At maximum one dimensional acceleration in [mm/s^2] at the elbow allowed. 
-     * @type {number}
-     * @memberof PlanningLimits
-     */
-    'elbow_acceleration_limit'?: number;
-    /**
-     * At maximum one dimensional force in [N] at the elbow allowed. 
-     * @type {number}
-     * @memberof PlanningLimits
-     */
-    'elbow_force_limit'?: number;
-}
-/**
- * The upper_limit must be greater then the lower_limit.
- * @export
- * @interface PlanningLimitsLimitRange
- */
-export interface PlanningLimitsLimitRange {
-    /**
-     * 
-     * @type {number}
-     * @memberof PlanningLimitsLimitRange
-     */
-    'lower_limit': number;
-    /**
-     * 
-     * @type {number}
-     * @memberof PlanningLimitsLimitRange
-     */
-    'upper_limit': number;
-}
 /**
  * Sets velocity for executed movements of the motion, in percent. Send after initializing the connection with InitializeMovementRequest. 
  * @export
@@ -3425,31 +3423,31 @@ export const PlaybackSpeedRequestMessageTypeEnum = {
 export type PlaybackSpeedRequestMessageTypeEnum = typeof PlaybackSpeedRequestMessageTypeEnum[keyof typeof PlaybackSpeedRequestMessageTypeEnum];
 
 /**
- * 
+ * Acknowledgment for PlaybackSpeedRequest message. 
  * @export
  * @interface PlaybackSpeedResponse
  */
 export interface PlaybackSpeedResponse {
     /**
-     * 
-     * @type {PlaybackSpeedResponsePlaybackSpeedResponse}
+     * Error message in case of invalid PlaybackSpeedRequest.
+     * @type {string}
      * @memberof PlaybackSpeedResponse
      */
-    'playback_speed_response': PlaybackSpeedResponsePlaybackSpeedResponse;
-}
-/**
- * 
- * @export
- * @interface PlaybackSpeedResponsePlaybackSpeedResponse
- */
-export interface PlaybackSpeedResponsePlaybackSpeedResponse {
+    'message'?: string;
     /**
-     * Value of the requested playback speed in percent [%].
-     * @type {number}
-     * @memberof PlaybackSpeedResponsePlaybackSpeedResponse
+     * 
+     * @type {string}
+     * @memberof PlaybackSpeedResponse
      */
-    'requested_value': number;
+    'kind': PlaybackSpeedResponseKindEnum;
 }
+
+export const PlaybackSpeedResponseKindEnum = {
+    PlaybackSpeedReceived: 'PLAYBACK_SPEED_RECEIVED'
+} as const;
+
+export type PlaybackSpeedResponseKindEnum = typeof PlaybackSpeedResponseKindEnum[keyof typeof PlaybackSpeedResponseKindEnum];
+
 /**
  * Defines a pose in 3D space. A pose is a combination of a position and an orientation. The position is applied before the orientation. 
  * @export
@@ -3832,10 +3830,10 @@ export interface RobotSetup {
     'tcp_offset'?: Pose;
     /**
      * 
-     * @type {PlanningLimits}
+     * @type {LimitSet}
      * @memberof RobotSetup
      */
-    'global_limits'?: PlanningLimits;
+    'global_limits'?: LimitSet;
     /**
      * 
      * @type {Payload}
@@ -3937,6 +3935,52 @@ export interface RobotTcps {
      */
     'tcps': Array<RobotTcp>;
 }
+/**
+ * 
+ * @export
+ * @interface Running
+ */
+export interface Running {
+    /**
+     * 
+     * @type {string}
+     * @memberof Running
+     */
+    'kind': RunningKindEnum;
+}
+
+export const RunningKindEnum = {
+    Running: 'RUNNING'
+} as const;
+
+export type RunningKindEnum = typeof RunningKindEnum[keyof typeof RunningKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface Running1
+ */
+export interface Running1 {
+    /**
+     * 
+     * @type {string}
+     * @memberof Running1
+     */
+    'kind': Running1KindEnum;
+    /**
+     * Remaining time in milliseconds (ms) to reach the end of the motion.
+     * @type {number}
+     * @memberof Running1
+     */
+    'time_to_end': number;
+}
+
+export const Running1KindEnum = {
+    Running: 'RUNNING'
+} as const;
+
+export type Running1KindEnum = typeof Running1KindEnum[keyof typeof Running1KindEnum];
+
 /**
  * Current safety state of the configured robot controller. Operation modes in which the attached motion groups can be moved are: - SAFETY_STATE_NORMAL - SAFETY_STATE_REDUCED All other modes are considered as non-operational. 
  * @export
@@ -4183,62 +4227,6 @@ export const SphereShapeTypeEnum = {
 
 export type SphereShapeTypeEnum = typeof SphereShapeTypeEnum[keyof typeof SphereShapeTypeEnum];
 
-/**
- * The response will be sent one time at the end of every execution signalling that the motion group has stopped moving.
- * @export
- * @interface Standstill
- */
-export interface Standstill {
-    /**
-     * 
-     * @type {StandstillStandstill}
-     * @memberof Standstill
-     */
-    'standstill': StandstillStandstill;
-}
-/**
- * The reason why the movement is paused.
- * @export
- * @enum {string}
- */
-
-export const StandstillReason = {
-    ReasonMotionEnded: 'REASON_MOTION_ENDED',
-    ReasonUserPausedMotion: 'REASON_USER_PAUSED_MOTION',
-    ReasonWaitingForIo: 'REASON_WAITING_FOR_IO',
-    ReasonPausedOnIo: 'REASON_PAUSED_ON_IO'
-} as const;
-
-export type StandstillReason = typeof StandstillReason[keyof typeof StandstillReason];
-
-
-/**
- * 
- * @export
- * @interface StandstillStandstill
- */
-export interface StandstillStandstill {
-    /**
-     * 
-     * @type {StandstillReason}
-     * @memberof StandstillStandstill
-     */
-    'reason': StandstillReason;
-    /**
-     * 
-     * @type {number}
-     * @memberof StandstillStandstill
-     */
-    'location': number;
-    /**
-     * Current state of the controller and motion group which came to a standstill.
-     * @type {RobotControllerState}
-     * @memberof StandstillStandstill
-     */
-    'state': RobotControllerState;
-}
-
-
 /**
  * Moves the motion group along a trajectory, added via [planTrajectory](planTrajectory) or [planMotion](planMotion). Trajectories can be executed forwards or backwards(\"in reverse\").  Pause the execution with PauseMovementRequest. Resume execution with StartMovementRequest.  Precondition: To start execution, the motion group must be located at the trajectory\'s start location specified in InitializeMovementRequest. 
  * @export
@@ -4283,6 +4271,32 @@ export const StartMovementRequestMessageTypeEnum = {
 
 export type StartMovementRequestMessageTypeEnum = typeof StartMovementRequestMessageTypeEnum[keyof typeof StartMovementRequestMessageTypeEnum];
 
+/**
+ * Acknowledgment for StartMovementRequest message. ATTENTION: No confirmation that the movement was started. Confirmation that the StartMovementRequest was received and is processed. Fields `execute` and `standstill` of response of [streamMotionGroupState](streamMotionGroupState) signal start of movement execution. 
+ * @export
+ * @interface StartMovementResponse
+ */
+export interface StartMovementResponse {
+    /**
+     * Error message in case of invalid StartMovementResquest.
+     * @type {string}
+     * @memberof StartMovementResponse
+     */
+    'message'?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof StartMovementResponse
+     */
+    'kind': StartMovementResponseKindEnum;
+}
+
+export const StartMovementResponseKindEnum = {
+    StartReceived: 'START_RECEIVED'
+} as const;
+
+export type StartMovementResponseKindEnum = typeof StartMovementResponseKindEnum[keyof typeof StartMovementResponseKindEnum];
+
 /**
  * Defines an input/output that the motion should wait for to start the execution.
  * @export
@@ -4399,6 +4413,32 @@ export const TcpVelocityRequestMessageTypeEnum = {
 
 export type TcpVelocityRequestMessageTypeEnum = typeof TcpVelocityRequestMessageTypeEnum[keyof typeof TcpVelocityRequestMessageTypeEnum];
 
+/**
+ * Acknowledgment to a TcpVelocityRequest. 
+ * @export
+ * @interface TcpVelocityResponse
+ */
+export interface TcpVelocityResponse {
+    /**
+     * Error message in case of invalid TcpVelocityRequest.
+     * @type {string}
+     * @memberof TcpVelocityResponse
+     */
+    'message'?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof TcpVelocityResponse
+     */
+    'kind': TcpVelocityResponseKindEnum;
+}
+
+export const TcpVelocityResponseKindEnum = {
+    TcpVelocityReceived: 'TCP_VELOCITY_RECEIVED'
+} as const;
+
+export type TcpVelocityResponseKindEnum = typeof TcpVelocityResponseKindEnum[keyof typeof TcpVelocityResponseKindEnum];
+
 /**
  * 
  * @export
@@ -4469,6 +4509,50 @@ export const TrajectoryDataMessageTypeEnum = {
 
 export type TrajectoryDataMessageTypeEnum = typeof TrajectoryDataMessageTypeEnum[keyof typeof TrajectoryDataMessageTypeEnum];
 
+/**
+ * State of trajectory execution. This state is sent during trajectory movement, response-rate closest to the nearest multiple of controller step-rate but not exceeding the configured rate. The trajectory state can be one of the following: - RUNNING: Trajectory is being executed. - PAUSED_BY_USER: User has paused execution. - END_OF_TRAJECTORY: First or last sample (depending on direction) of trajectory has been sent. - WAIT_FOR_IO: Waiting for an I/O event to start execution. - PAUSED_ON_IO: Execution was paused because of an I/O event. 
+ * @export
+ * @interface TrajectoryDetails
+ */
+export interface TrajectoryDetails {
+    /**
+     * Unique identifier of the trajectory being executed. 
+     * @type {string}
+     * @memberof TrajectoryDetails
+     */
+    'trajectory': string;
+    /**
+     * Current location of motion group on the trajectory.
+     * @type {number}
+     * @memberof TrajectoryDetails
+     */
+    'location': number;
+    /**
+     * 
+     * @type {TrajectoryDetailsState}
+     * @memberof TrajectoryDetails
+     */
+    'state': TrajectoryDetailsState;
+    /**
+     * Discriminator for OpenApi generators, which is always \"TRAJECTORY\" for this schema. 
+     * @type {string}
+     * @memberof TrajectoryDetails
+     */
+    'kind': TrajectoryDetailsKindEnum;
+}
+
+export const TrajectoryDetailsKindEnum = {
+    Trajectory: 'TRAJECTORY'
+} as const;
+
+export type TrajectoryDetailsKindEnum = typeof TrajectoryDetailsKindEnum[keyof typeof TrajectoryDetailsKindEnum];
+
+/**
+ * @type TrajectoryDetailsState
+ * @export
+ */
+export type TrajectoryDetailsState = EndOfTrajectory | PausedByRequest | PausedOnIO | Running1 | WaitForIO;
+
 /**
  * 
  * @export
@@ -4480,7 +4564,7 @@ export interface TrajectoryId {
      * @type {string}
      * @memberof TrajectoryId
      */
-    'message_type': TrajectoryIdMessageTypeEnum;
+    'message_type'?: TrajectoryIdMessageTypeEnum;
     /**
      * The identifier of the trajectory which was returned by the [addTrajectory](addTrajectory) endpoint. 
      * @type {string}
@@ -4796,6 +4880,26 @@ export interface VirtualRobotConfiguration {
      */
     'content': string;
 }
+/**
+ * 
+ * @export
+ * @interface WaitForIO
+ */
+export interface WaitForIO {
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitForIO
+     */
+    'kind': WaitForIOKindEnum;
+}
+
+export const WaitForIOKindEnum = {
+    WaitForIo: 'WAIT_FOR_IO'
+} as const;
+
+export type WaitForIOKindEnum = typeof WaitForIOKindEnum[keyof typeof WaitForIOKindEnum];
+
 /**
  * The value to compare with the current value of the input/output.
  * @export
@@ -8921,7 +9025,7 @@ export const MotionGroupApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async streamMotionGroupState(cell: string, motionGroup: string, responseRate?: number, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MotionGroupStateWithoutPayload>> {
+        async streamMotionGroupState(cell: string, motionGroup: string, responseRate?: number, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MotionGroupState>> {
             const localVarAxiosArgs = await localVarAxiosParamCreator.streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['MotionGroupApi.streamMotionGroupState']?.[localVarOperationServerIndex]?.url;
@@ -8970,7 +9074,7 @@ export const MotionGroupApiFactory = function (configuration?: Configuration, ba
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        streamMotionGroupState(cell: string, motionGroup: string, responseRate?: number, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig): AxiosPromise<MotionGroupStateWithoutPayload> {
+        streamMotionGroupState(cell: string, motionGroup: string, responseRate?: number, responseCoordinateSystem?: string, options?: RawAxiosRequestConfig): AxiosPromise<MotionGroupState> {
             return localVarFp.streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options).then((request) => request(axios, basePath));
         },
     };