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

package/v2/api.ts

@@ -959,6 +959,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 +992,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 +1039,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 +1658,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 +1741,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
@@ -1842,159 +1881,36 @@ 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. 
+ * 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 JoggingErrorResponse
+ * @interface JoggingDetails
  */
-export interface JoggingErrorResponse {
+export interface JoggingDetails {
     /**
      * 
-     * @type {JoggingErrorResponseError}
-     * @memberof JoggingErrorResponse
+     * @type {JoggingDetailsState}
+     * @memberof JoggingDetails
      */
-    'error': JoggingErrorResponseError;
-}
-/**
- * 
- * @export
- * @interface JoggingErrorResponseError
- */
-export interface JoggingErrorResponseError {
-    /**
-     * Error description.
-     * @type {string}
-     * @memberof JoggingErrorResponseError
-     */
-    'error_message': string;
-}
-/**
- * 
- * @export
- * @interface JoggingPausedCollision
- */
-export interface JoggingPausedCollision {
-    /**
-     * 
-     * @type {JoggingPausedCollisionPausedNearCollision}
-     * @memberof JoggingPausedCollision
-     */
-    '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
-     */
-    'joint_indices'?: Array<number>;
-}
-/**
- * 
- * @export
- * @interface JoggingPausedOnIO
- */
-export interface JoggingPausedOnIO {
-    /**
-     * 
-     * @type {object}
-     * @memberof JoggingPausedOnIO
+     * @memberof JoggingDetails
      */
-    'paused_on_io': object;
-}
-/**
- * 
- * @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
- */
-export interface JoggingResponse {
-    /**
-     * 
-     * @type {JoggingResponseJogging}
-     * @memberof JoggingResponse
-     */
-    'jogging': JoggingResponseJogging;
-}
-/**
- * 
- * @export
- * @interface JoggingResponseJogging
- */
-export interface JoggingResponseJogging {
-    /**
-     * 
-     * @type {JoggingState}
-     * @memberof JoggingResponseJogging
-     */
-    'jogging_state': JoggingState;
-    /**
-     * 
-     * @type {RobotControllerState}
-     * @memberof JoggingResponseJogging
-     */
-    'robot_controller_state': RobotControllerState;
-}
-/**
- * 
- * @export
- * @interface JoggingRunning
- */
-export interface JoggingRunning {
-    /**
-     * 
-     * @type {object}
-     * @memberof JoggingRunning
-     */
-    'running': object;
+    'kind': JoggingDetailsKindEnum;
 }
+
+export const JoggingDetailsKindEnum = {
+    Jogging: 'JOGGING'
+} as const;
+
+export type JoggingDetailsKindEnum = typeof JoggingDetailsKindEnum[keyof typeof JoggingDetailsKindEnum];
+
 /**
- * @type JoggingState
+ * @type JoggingDetailsState
  * @export
  */
-export type JoggingState = JoggingPausedCollision | JoggingPausedJointLimit | JoggingPausedOnIO | JoggingPausedUserRequest | JoggingRunning;
+export type JoggingDetailsState = PausedByUser | PausedNearCollision | PausedNearJointLimit | PausedOnIO | Running;
 
 /**
  * 
@@ -2060,6 +1976,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
@@ -2530,17 +2472,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 +2514,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 +2581,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 +2607,31 @@ export interface MotionState {
     'state': RobotState;
 }
 /**
- * 
+ * Error message in case an error occurs during movement execution. 
  * @export
- * @interface MotionVector
+ * @interface MovementErrorResponse
  */
-export interface MotionVector {
+export interface MovementErrorResponse {
     /**
-     * A three-dimensional vector [x, y, z] with double precision. 
-     * @type {Array<number>}
-     * @memberof MotionVector
-     */
-    'linear'?: Array<number>;
-    /**
-     * 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
-     */
-    '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
+     * @memberof MovementErrorResponse
      */
-    '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
+     * @memberof MovementErrorResponse
      */
-    '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
-     */
-    'state': RobotControllerState;
+    'kind': MovementErrorResponseKindEnum;
 }
+
+export const MovementErrorResponseKindEnum = {
+    Error: 'ERROR'
+} as const;
+
+export type MovementErrorResponseKindEnum = typeof MovementErrorResponseKindEnum[keyof typeof MovementErrorResponseKindEnum];
+
 /**
  * 
  * @export
@@ -3028,151 +2816,297 @@ export interface PathCubicSpline {
      * @type {Array<CubicSplineParameter>}
      * @memberof PathCubicSpline
      */
-    'parameters': Array<CubicSplineParameter>;
+    'parameters': Array<CubicSplineParameter>;
+    /**
+     * 
+     * @type {string}
+     * @memberof PathCubicSpline
+     */
+    'path_definition_name': PathCubicSplinePathDefinitionNameEnum;
+}
+
+export const PathCubicSplinePathDefinitionNameEnum = {
+    PathCubicSpline: 'PathCubicSpline'
+} as const;
+
+export type PathCubicSplinePathDefinitionNameEnum = typeof PathCubicSplinePathDefinitionNameEnum[keyof typeof PathCubicSplinePathDefinitionNameEnum];
+
+/**
+ * A joint point-to-point represents a line in joint space. All joints will be moved synchronously. 
+ * @export
+ * @interface PathJointPTP
+ */
+export interface PathJointPTP {
+    /**
+     * 
+     * @type {Array<number>}
+     * @memberof PathJointPTP
+     */
+    'target_joint_position': Array<number>;
+    /**
+     * 
+     * @type {string}
+     * @memberof PathJointPTP
+     */
+    'path_definition_name': PathJointPTPPathDefinitionNameEnum;
+}
+
+export const PathJointPTPPathDefinitionNameEnum = {
+    PathJointPtp: 'PathJointPTP'
+} as const;
+
+export type PathJointPTPPathDefinitionNameEnum = typeof PathJointPTPPathDefinitionNameEnum[keyof typeof PathJointPTPPathDefinitionNameEnum];
+
+/**
+ * A line represents a straight line from start position to indicated target position. The orientation is calculated via a quaternion [slerp](https://en.wikipedia.org/wiki/Slerp) from start orientation to indicated target orientation. 
+ * @export
+ * @interface PathLine
+ */
+export interface PathLine {
+    /**
+     * 
+     * @type {Pose}
+     * @memberof PathLine
+     */
+    'target_pose': Pose;
+    /**
+     * 
+     * @type {string}
+     * @memberof PathLine
+     */
+    'path_definition_name': PathLinePathDefinitionNameEnum;
+}
+
+export const PathLinePathDefinitionNameEnum = {
+    PathLine: 'PathLine'
+} as const;
+
+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
+ * @interface PauseMovementRequest
+ */
+export interface PauseMovementRequest {
+    /**
+     * Type specifier for server, set automatically. 
+     * @type {string}
+     * @memberof PauseMovementRequest
+     */
+    'message_type'?: PauseMovementRequestMessageTypeEnum;
+}
+
+export const PauseMovementRequestMessageTypeEnum = {
+    PauseMovementRequest: 'PauseMovementRequest'
+} as const;
+
+export type PauseMovementRequestMessageTypeEnum = typeof PauseMovementRequestMessageTypeEnum[keyof typeof PauseMovementRequestMessageTypeEnum];
+
+/**
+ * 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 {
+    /**
+     * Error message in case of invalid PauseMovementResquest.
+     * @type {string}
+     * @memberof PauseMovementResponse
+     */
+    'message'?: string;
     /**
      * 
      * @type {string}
-     * @memberof PathCubicSpline
+     * @memberof PauseMovementResponse
      */
-    'path_definition_name': PathCubicSplinePathDefinitionNameEnum;
+    'kind': PauseMovementResponseKindEnum;
 }
 
-export const PathCubicSplinePathDefinitionNameEnum = {
-    PathCubicSpline: 'PathCubicSpline'
+export const PauseMovementResponseKindEnum = {
+    PauseReceived: 'PAUSE_RECEIVED'
 } as const;
 
-export type PathCubicSplinePathDefinitionNameEnum = typeof PathCubicSplinePathDefinitionNameEnum[keyof typeof PathCubicSplinePathDefinitionNameEnum];
+export type PauseMovementResponseKindEnum = typeof PauseMovementResponseKindEnum[keyof typeof PauseMovementResponseKindEnum];
 
 /**
- * A joint point-to-point represents a line in joint space. All joints will be moved synchronously. 
+ * Defines an input/output that the motion will be paused for. The motion will stop gracefully on path.
  * @export
- * @interface PathJointPTP
+ * @interface PauseOnIO
  */
-export interface PathJointPTP {
+export interface PauseOnIO {
     /**
      * 
-     * @type {Array<number>}
-     * @memberof PathJointPTP
+     * @type {IOValue}
+     * @memberof PauseOnIO
      */
-    'target_joint_position': Array<number>;
+    'io': IOValue;
     /**
-     * 
-     * @type {string}
-     * @memberof PathJointPTP
+     * Comparator for the comparison of two values. Use the measured I/O as the base value (a) and the expected input/output value as the comparator (b): e.g., a > b. 
+     * @type {Comparator}
+     * @memberof PauseOnIO
      */
-    'path_definition_name': PathJointPTPPathDefinitionNameEnum;
+    'comparator': Comparator;
 }
 
-export const PathJointPTPPathDefinitionNameEnum = {
-    PathJointPtp: 'PathJointPTP'
-} as const;
-
-export type PathJointPTPPathDefinitionNameEnum = typeof PathJointPTPPathDefinitionNameEnum[keyof typeof PathJointPTPPathDefinitionNameEnum];
 
 /**
- * A line represents a straight line from start position to indicated target position. The orientation is calculated via a quaternion [slerp](https://en.wikipedia.org/wiki/Slerp) from start orientation to indicated target orientation. 
+ * 
  * @export
- * @interface PathLine
+ * @interface PausedByRequest
  */
-export interface PathLine {
-    /**
-     * 
-     * @type {Pose}
-     * @memberof PathLine
-     */
-    'target_pose': Pose;
+export interface PausedByRequest {
     /**
      * 
      * @type {string}
-     * @memberof PathLine
+     * @memberof PausedByRequest
      */
-    'path_definition_name': PathLinePathDefinitionNameEnum;
+    'kind': PausedByRequestKindEnum;
 }
 
-export const PathLinePathDefinitionNameEnum = {
-    PathLine: 'PathLine'
+export const PausedByRequestKindEnum = {
+    PausedByUser: 'PAUSED_BY_USER'
 } as const;
 
-export type PathLinePathDefinitionNameEnum = typeof PathLinePathDefinitionNameEnum[keyof typeof PathLinePathDefinitionNameEnum];
+export type PausedByRequestKindEnum = typeof PausedByRequestKindEnum[keyof typeof PausedByRequestKindEnum];
 
 /**
- * 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
- * @interface PauseMovementRequest
+ * @interface PausedByUser
  */
-export interface PauseMovementRequest {
+export interface PausedByUser {
     /**
-     * Type specifier for server, set automatically. 
+     * 
      * @type {string}
-     * @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
+     * @memberof PausedByUser
      */
-    'send_response'?: boolean;
+    'kind': PausedByUserKindEnum;
 }
 
-export const PauseMovementRequestMessageTypeEnum = {
-    PauseMovementRequest: 'PauseMovementRequest'
+export const PausedByUserKindEnum = {
+    PausedByUser: 'PAUSED_BY_USER'
 } as const;
 
-export type PauseMovementRequestMessageTypeEnum = typeof PauseMovementRequestMessageTypeEnum[keyof typeof PauseMovementRequestMessageTypeEnum];
+export type PausedByUserKindEnum = typeof PausedByUserKindEnum[keyof typeof PausedByUserKindEnum];
 
 /**
- * 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). 
+ * 
  * @export
- * @interface PauseMovementResponse
+ * @interface PausedNearCollision
  */
-export interface PauseMovementResponse {
+export interface PausedNearCollision {
     /**
      * 
-     * @type {PauseMovementResponsePauseResponse}
-     * @memberof PauseMovementResponse
+     * @type {string}
+     * @memberof PausedNearCollision
+     */
+    'kind': PausedNearCollisionKindEnum;
+    /**
+     * 
+     * @type {string}
+     * @memberof PausedNearCollision
      */
-    'pause_response': PauseMovementResponsePauseResponse;
+    'description': string;
 }
+
+export const PausedNearCollisionKindEnum = {
+    PausedNearCollision: 'PAUSED_NEAR_COLLISION'
+} as const;
+
+export type PausedNearCollisionKindEnum = typeof PausedNearCollisionKindEnum[keyof typeof PausedNearCollisionKindEnum];
+
 /**
  * 
  * @export
- * @interface PauseMovementResponsePauseResponse
+ * @interface PausedNearJointLimit
  */
-export interface PauseMovementResponsePauseResponse {
+export interface PausedNearJointLimit {
     /**
-     * Indicates if PauseMovementRequest can be executed.
-     * @type {boolean}
-     * @memberof PauseMovementResponsePauseResponse
+     * 
+     * @type {string}
+     * @memberof PausedNearJointLimit
      */
-    'succeeded': boolean;
+    'kind': PausedNearJointLimitKindEnum;
     /**
-     * Error message in case of invalid PauseMovementRequest or failure while claiming motion. 
-     * @type {string}
-     * @memberof PauseMovementResponsePauseResponse
+     * 
+     * @type {Array<number>}
+     * @memberof PausedNearJointLimit
      */
-    'error_message'?: string;
+    'joint_indices': Array<number>;
 }
+
+export const PausedNearJointLimitKindEnum = {
+    PausedNearJointLimit: 'PAUSED_NEAR_JOINT_LIMIT'
+} as const;
+
+export type PausedNearJointLimitKindEnum = typeof PausedNearJointLimitKindEnum[keyof typeof PausedNearJointLimitKindEnum];
+
 /**
- * Defines an input/output that the motion will be paused for. The motion will stop gracefully on path.
+ * 
  * @export
- * @interface PauseOnIO
+ * @interface PausedOnIO
  */
-export interface PauseOnIO {
+export interface PausedOnIO {
     /**
      * 
-     * @type {IOValue}
-     * @memberof PauseOnIO
-     */
-    'io': IOValue;
-    /**
-     * Comparator for the comparison of two values. Use the measured I/O as the base value (a) and the expected input/output value as the comparator (b): e.g., a > b. 
-     * @type {Comparator}
-     * @memberof PauseOnIO
+     * @type {string}
+     * @memberof PausedOnIO
      */
-    'comparator': Comparator;
+    'kind': PausedOnIOKindEnum;
 }
 
+export const PausedOnIOKindEnum = {
+    PausedOnIo: 'PAUSED_ON_IO'
+} as const;
+
+export type PausedOnIOKindEnum = typeof PausedOnIOKindEnum[keyof typeof PausedOnIOKindEnum];
 
 /**
  * 
@@ -3425,31 +3359,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
@@ -3937,6 +3871,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 +4163,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 +4207,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 +4349,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 +4445,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 +4500,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 +4816,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 +8961,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 +9010,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));
         },
     };