@wandelbots/nova-api 25.7.0-dev.9 → 25.7.0-rc.2

package/v2/api.ts

@@ -210,6 +210,12 @@ export interface App {
      * @memberof App
      */
     'storage'?: ContainerStorage;
+    /**
+     * 
+     * @type {ContainerResources}
+     * @memberof App
+     */
+    'resources'?: ContainerResources;
     /**
      * Defines the URL path suffix used to check the application\'s health status. The complete health check URL is constructed as `/$cell/$name/$health_path`. When the application is working as expected, the endpoint returns an HTTP 200 status code.  If not specified, the system will default to using the application icon path suffix (the value of `app_icon`) as the health check endpoint, resulting in `/$cell/$name/$app_icon`.  If the health check fails (no response or non-200 status code), the system will automatically restart the application container to restore service. 
      * @type {string}
@@ -514,13 +520,13 @@ export interface Collision {
      * @type {string}
      * @memberof Collision
      */
-    'id_of_world'?: string;
+    'id_of_layer'?: string;
     /**
      * A three-dimensional vector [x, y, z] with double precision. 
      * @type {Array<number>}
      * @memberof Collision
      */
-    'normal_world_on_b'?: Array<number>;
+    'normal_root_on_b'?: Array<number>;
     /**
      * 
      * @type {CollisionContact}
@@ -551,7 +557,7 @@ export interface CollisionContact {
      * @type {Array<number>}
      * @memberof CollisionContact
      */
-    'world'?: Array<number>;
+    'root'?: Array<number>;
 }
 /**
  * 
@@ -567,110 +573,42 @@ export interface CollisionError {
     'collision'?: FeedbackCollision;
 }
 /**
- * 
+ * @type CollisionFreeAlgorithm
+ * Configuration for collision-free path planning algorithms. Different algorithms may have different parameters and behavior. 
  * @export
- * @interface CollisionMotionGroup
  */
-export interface CollisionMotionGroup {
-    /**
-     * A link chain is a kinematic chain of links that is connected via joints. A motion group can be used to control the motion of the joints in a link chain.  A link is a group of colliders that is attached to the link reference frame.  The reference frame of a link is obtained after applying all sets of Denavit-Hartenberg-parameters from base to (including) the link index.  This means that the reference frame of the link is on the rotation axis of the next joint in the kinematic chain. Example: For a motion group with 2 joints, the collider reference frame (CRF) for link 1 is on the rotation axis of joint 2. The chain looks like: - Origin >> Mounting >> Base >> (CRF Base) Joint 0 >> Link 0 >> (CRF Link 0) Joint 1 >> Link 1 >> (CRF Link 1) Flange (CRF Tool) >> TCP  Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. 
-     * @type {Array<{ [key: string]: Collider; }>}
-     * @memberof CollisionMotionGroup
-     */
-    'link_chain'?: Array<{ [key: string]: Collider; }>;
-    /**
-     * Defines the shape of a tool.  A tool is a dictionary of colliders.  All colliders that make up a tool are attached to the flange frame of the motion group. 
-     * @type {{ [key: string]: Collider; }}
-     * @memberof CollisionMotionGroup
-     */
-    'tool'?: { [key: string]: Collider; };
-}
+export type CollisionFreeAlgorithm = MidpointInsertionAlgorithm | RRTConnectAlgorithm;
+
 /**
  * 
  * @export
- * @interface CollisionMotionGroupAssembly
+ * @interface CollisionSetup
  */
-export interface CollisionMotionGroupAssembly {
-    /**
-     * References a stored link chain. 
-     * @type {string}
-     * @memberof CollisionMotionGroupAssembly
-     */
-    'stored_link_chain'?: string;
+export interface CollisionSetup {
     /**
-     * References a stored tool. 
-     * @type {string}
-     * @memberof CollisionMotionGroupAssembly
+     * A collection of identifiable colliders.
+     * @type {{ [key: string]: Collider; }}
+     * @memberof CollisionSetup
      */
-    'stored_tool'?: string;
+    'colliders'?: { [key: string]: Collider; };
     /**
      * A link chain is a kinematic chain of links that is connected via joints. A motion group can be used to control the motion of the joints in a link chain.  A link is a group of colliders that is attached to the link reference frame.  The reference frame of a link is obtained after applying all sets of Denavit-Hartenberg-parameters from base to (including) the link index.  This means that the reference frame of the link is on the rotation axis of the next joint in the kinematic chain. Example: For a motion group with 2 joints, the collider reference frame (CRF) for link 1 is on the rotation axis of joint 2. The chain looks like: - Origin >> Mounting >> Base >> (CRF Base) Joint 0 >> Link 0 >> (CRF Link 0) Joint 1 >> Link 1 >> (CRF Link 1) Flange (CRF Tool) >> TCP  Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. 
      * @type {Array<{ [key: string]: Collider; }>}
-     * @memberof CollisionMotionGroupAssembly
+     * @memberof CollisionSetup
      */
     'link_chain'?: Array<{ [key: string]: Collider; }>;
     /**
      * Defines the shape of a tool.  A tool is a dictionary of colliders.  All colliders that make up a tool are attached to the flange frame of the motion group. 
      * @type {{ [key: string]: Collider; }}
-     * @memberof CollisionMotionGroupAssembly
+     * @memberof CollisionSetup
      */
     'tool'?: { [key: string]: Collider; };
-}
-/**
- * Defines the collision scene.  There are two types of objects in the scene: - `colliders`: Each collider is attached directly to the origin of the scene: Origin >> Collider - `motion-groups`: Each motion group is assigned a kinematic chain of links with a special collider, called tool, attached to the last element.   The motion group is attached to the origin of the scene via its mounting: Origin >> Mounting >> Motion Group Base >> […] 
- * @export
- * @interface CollisionScene
- */
-export interface CollisionScene {
-    /**
-     * A collection of identifiable colliders.
-     * @type {{ [key: string]: Collider; }}
-     * @memberof CollisionScene
-     */
-    'colliders'?: { [key: string]: Collider; };
-    /**
-     * Maps a Wandelbots NOVA motion group to its configuration in the collision scene. Key must be a motion group identifier.  Values are collision motion group objects.  A collision motion group defines a motion group in the collision scene.  The motion group is attached to the origin of the scene. To relocate the motion group, configure its mounting offset on the physical controller. This ensures that the definition of motion commands and collision scenes use the same coordinate system. The kinematic chain looks like this: - Origin >> Mounting >> Base >> Joint 0 >> Link 0 >> Joint 1 >> […] >> TCP  A `tool` is treated like another link attached to the end (flange) of the kinematic chain. All tool colliders are described in the flange frame. 
-     * @type {{ [key: string]: CollisionMotionGroup; }}
-     * @memberof CollisionScene
-     */
-    'motion_groups'?: { [key: string]: CollisionMotionGroup; };
-}
-/**
- * Defines the collision scene assembly. Merges all referenced and new scene components into a single scene.  Previously added components with identical identifiers are overwritten within the same group.  There is one group for each of the following components: - Colliders attached to the origin of the scene, - Tool per motion group, and - For each link per motion group.  The scene is assembled by adding components in the following order. 1. stored_scenes 2. scene 3. stored_colliders 4. colliders 5. stored_link_chains and stored_tools (per motion group) 6. link_chains and tools (per motion group) 
- * @export
- * @interface CollisionSceneAssembly
- */
-export interface CollisionSceneAssembly {
-    /**
-     * Add stored scenes to the scene via their identifiers. The scenes are merged based on their order in the array. The scene at index zero serves as base. Following scenes overwrite components with identical identifiers, see [Collision Scene Assembly](Collision Scene Assembly). 
-     * @type {Array<string>}
-     * @memberof CollisionSceneAssembly
-     */
-    'stored_scenes'?: Array<string>;
-    /**
-     * 
-     * @type {CollisionScene}
-     * @memberof CollisionSceneAssembly
-     */
-    'scene'?: CollisionScene;
-    /**
-     * Add stored colliders to the scene via their identifiers. The colliders are added to the the origin of the scene. 
-     * @type {Array<string>}
-     * @memberof CollisionSceneAssembly
-     */
-    'stored_colliders'?: Array<string>;
     /**
-     * A collection of identifiable colliders.
-     * @type {{ [key: string]: Collider; }}
-     * @memberof CollisionSceneAssembly
-     */
-    'colliders'?: { [key: string]: Collider; };
-    /**
-     * Maps a Wandelbots NOVA motion group to its assembly configuration in the collision scene. Key must be a motion group identifier.  A collision motion group defines a motion group in the collision scene.  The motion group is attached to the origin of the scene. To relocate the motion group, configure its mounting offset on the physical controller. This ensures that the definition of motion commands and collision scenes use the same coordinate system. The kinematic chain looks like this: - Origin >> Mounting >> Base >> Joint 0 >> Link 0 >> Joint 1 >> […] >> TCP  A `tool` is treated like another link attached to the end (flange) of the kinematic chain. All tool colliders are described in the flange frame. 
-     * @type {{ [key: string]: CollisionMotionGroupAssembly; }}
-     * @memberof CollisionSceneAssembly
+     * If true, self-collision detection is enabled for the motion group.  Self-collision detection checks if links in the kinematic chain of the motion group collide with each other. Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. The tool is treated like a link at the end of the kinematic chain. It is checked against all links except the last one.  Default is true. 
+     * @type {boolean}
+     * @memberof CollisionSetup
      */
-    'motion_groups'?: { [key: string]: CollisionMotionGroupAssembly; };
+    'self_collision_detection'?: boolean;
 }
 /**
  * Comparator for the comparison of two values. The comparator is used to compare two values and return a boolean result. The default comparator is unknown. 
@@ -851,6 +789,25 @@ export interface ContainerImageSecretsInner {
      */
     'name': string;
 }
+/**
+ * Additional resources that the application requires.
+ * @export
+ * @interface ContainerResources
+ */
+export interface ContainerResources {
+    /**
+     * Number of GPUs the application requires.
+     * @type {number}
+     * @memberof ContainerResources
+     */
+    'intel_gpu'?: number;
+    /**
+     * The maximum memory allocated to this application.
+     * @type {string}
+     * @memberof ContainerResources
+     */
+    'memory_limit'?: string;
+}
 /**
  * The path and capacity of a volume that retains data across application restarts. The maximal requestable capacity is 300Mi. If you need more capacity consider using [storeObject](storeObject). 
  * @export
@@ -1127,24 +1084,126 @@ export type Direction = typeof Direction[keyof typeof Direction];
 
 
 /**
- * 
+ * The provided joint data does not match the expected number of joints for this motion group. 
  * @export
- * @interface EndOfTrajectory
+ * @interface ErrorInvalidJointCount
  */
-export interface EndOfTrajectory {
+export interface ErrorInvalidJointCount {
+    /**
+     * The expected number of joints for this motion group. 
+     * @type {number}
+     * @memberof ErrorInvalidJointCount
+     */
+    'expected_joint_count': number;
+    /**
+     * The number of provided joints. 
+     * @type {number}
+     * @memberof ErrorInvalidJointCount
+     */
+    'provided_joint_count': number;
     /**
      * 
      * @type {string}
-     * @memberof EndOfTrajectory
+     * @memberof ErrorInvalidJointCount
      */
-    'kind': EndOfTrajectoryKindEnum;
+    'error_feedback_name': ErrorInvalidJointCountErrorFeedbackNameEnum;
 }
 
-export const EndOfTrajectoryKindEnum = {
-    EndOfTrajectory: 'END_OF_TRAJECTORY'
+export const ErrorInvalidJointCountErrorFeedbackNameEnum = {
+    ErrorInvalidJointCount: 'ErrorInvalidJointCount'
+} as const;
+
+export type ErrorInvalidJointCountErrorFeedbackNameEnum = typeof ErrorInvalidJointCountErrorFeedbackNameEnum[keyof typeof ErrorInvalidJointCountErrorFeedbackNameEnum];
+
+/**
+ * A reference joint position (start or target) exceeds the configured joint limits. 
+ * @export
+ * @interface ErrorJointLimitExceeded
+ */
+export interface ErrorJointLimitExceeded {
+    /**
+     * Index of the joint exceeding its limits (0-based). 
+     * @type {number}
+     * @memberof ErrorJointLimitExceeded
+     */
+    'joint_index'?: number;
+    /**
+     * 
+     * @type {Array<number>}
+     * @memberof ErrorJointLimitExceeded
+     */
+    'joint_position'?: Array<number>;
+    /**
+     * 
+     * @type {string}
+     * @memberof ErrorJointLimitExceeded
+     */
+    'error_feedback_name': ErrorJointLimitExceededErrorFeedbackNameEnum;
+}
+
+export const ErrorJointLimitExceededErrorFeedbackNameEnum = {
+    ErrorJointLimitExceeded: 'ErrorJointLimitExceeded'
+} as const;
+
+export type ErrorJointLimitExceededErrorFeedbackNameEnum = typeof ErrorJointLimitExceededErrorFeedbackNameEnum[keyof typeof ErrorJointLimitExceededErrorFeedbackNameEnum];
+
+/**
+ * A reference joint position (e.g. start or target joint position) results in collisions that prevent processing. 
+ * @export
+ * @interface ErrorJointPositionCollision
+ */
+export interface ErrorJointPositionCollision {
+    /**
+     * 
+     * @type {Array<Collision>}
+     * @memberof ErrorJointPositionCollision
+     */
+    'collisions'?: Array<Collision>;
+    /**
+     * 
+     * @type {Array<number>}
+     * @memberof ErrorJointPositionCollision
+     */
+    'joint_position'?: Array<number>;
+    /**
+     * 
+     * @type {string}
+     * @memberof ErrorJointPositionCollision
+     */
+    'error_feedback_name': ErrorJointPositionCollisionErrorFeedbackNameEnum;
+}
+
+export const ErrorJointPositionCollisionErrorFeedbackNameEnum = {
+    ErrorJointPositionCollision: 'ErrorJointPositionCollision'
+} as const;
+
+export type ErrorJointPositionCollisionErrorFeedbackNameEnum = typeof ErrorJointPositionCollisionErrorFeedbackNameEnum[keyof typeof ErrorJointPositionCollisionErrorFeedbackNameEnum];
+
+/**
+ * The collision-free planning algorithm reached its maximum iteration limit without finding a valid path. Increase max_iterations or modify the start/target positions. 
+ * @export
+ * @interface ErrorMaxIterationsExceeded
+ */
+export interface ErrorMaxIterationsExceeded {
+    /**
+     * The maximum number of iterations that was reached. 
+     * @type {number}
+     * @memberof ErrorMaxIterationsExceeded
+     */
+    'max_iterations'?: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof ErrorMaxIterationsExceeded
+     */
+    'error_feedback_name': ErrorMaxIterationsExceededErrorFeedbackNameEnum;
+}
+
+export const ErrorMaxIterationsExceededErrorFeedbackNameEnum = {
+    ErrorMaxIterationsExceeded: 'ErrorMaxIterationsExceeded'
 } as const;
 
-export type EndOfTrajectoryKindEnum = typeof EndOfTrajectoryKindEnum[keyof typeof EndOfTrajectoryKindEnum];
+export type ErrorMaxIterationsExceededErrorFeedbackNameEnum = typeof ErrorMaxIterationsExceededErrorFeedbackNameEnum[keyof typeof ErrorMaxIterationsExceededErrorFeedbackNameEnum];
 
 /**
  * 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. 
@@ -1423,18 +1482,97 @@ export type FloatValueValueTypeEnum = typeof FloatValueValueTypeEnum[keyof typeo
 /**
  * 
  * @export
- * @interface GetModeResponse
+ * @interface ForwardKinematics422Response
  */
-export interface GetModeResponse {
+export interface ForwardKinematics422Response {
     /**
      * 
-     * @type {RobotSystemMode}
-     * @memberof GetModeResponse
+     * @type {Array<ForwardKinematicsValidationError>}
+     * @memberof ForwardKinematics422Response
      */
-    'robot_system_mode': RobotSystemMode;
+    'detail'?: Array<ForwardKinematicsValidationError>;
+}
+/**
+ * 
+ * @export
+ * @interface ForwardKinematicsRequest
+ */
+export interface ForwardKinematicsRequest {
+    /**
+     * String identifiying the model of a motion group.
+     * @type {string}
+     * @memberof ForwardKinematicsRequest
+     */
+    'motion_group_model': string;
+    /**
+     * List of joint positions [rad] for which TCP poses are computed. 
+     * @type {Array<Array<number>>}
+     * @memberof ForwardKinematicsRequest
+     */
+    'joint_positions': Array<Array<number>>;
+    /**
+     * 
+     * @type {Pose}
+     * @memberof ForwardKinematicsRequest
+     */
+    'tcp_offset'?: Pose;
+    /**
+     * Offset from the world frame to the motion group base.
+     * @type {Pose}
+     * @memberof ForwardKinematicsRequest
+     */
+    'mounting'?: Pose;
+}
+/**
+ * 
+ * @export
+ * @interface ForwardKinematicsResponse
+ */
+export interface ForwardKinematicsResponse {
+    /**
+     * List of computed TCP poses corresponding to the input joint positions. 
+     * @type {Array<Pose>}
+     * @memberof ForwardKinematicsResponse
+     */
+    'tcp_poses': Array<Pose>;
+}
+/**
+ * 
+ * @export
+ * @interface ForwardKinematicsValidationError
+ */
+export interface ForwardKinematicsValidationError {
+    /**
+     * 
+     * @type {Array<ValidationErrorLocInner>}
+     * @memberof ForwardKinematicsValidationError
+     */
+    'loc': Array<ValidationErrorLocInner>;
+    /**
+     * 
+     * @type {string}
+     * @memberof ForwardKinematicsValidationError
+     */
+    'msg': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof ForwardKinematicsValidationError
+     */
+    'type': string;
+    /**
+     * 
+     * @type {{ [key: string]: any; }}
+     * @memberof ForwardKinematicsValidationError
+     */
+    'input': { [key: string]: any; };
+    /**
+     * 
+     * @type {ErrorInvalidJointCount}
+     * @memberof ForwardKinematicsValidationError
+     */
+    'data'?: ErrorInvalidJointCount;
 }
-
-
 /**
  * 
  * @export
@@ -1947,6 +2085,19 @@ export interface InvalidDofInvalidDof {
      */
     'joint_position'?: Array<number>;
 }
+/**
+ * 
+ * @export
+ * @interface InverseKinematics422Response
+ */
+export interface InverseKinematics422Response {
+    /**
+     * 
+     * @type {Array<InverseKinematicsValidationError>}
+     * @memberof InverseKinematics422Response
+     */
+    'detail'?: Array<InverseKinematicsValidationError>;
+}
 /**
  * 
  * @export
@@ -1984,11 +2135,11 @@ export interface InverseKinematicsRequest {
      */
     '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; }}
+     * Collision layers to be respected by the motion planner when planning for a single motion group. Each setup represents one layer, e.g. the safety zones and shapes or a fine grained tool and workpiece model. Layers are checked individually along the trajectory and independently of other layers.  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 layer. 3. Create other layers from your own 3D data as needed. 4. Plan trajectory. 5. The response highlights the layer in which a collision was detected by key. 
+     * @type {{ [key: string]: CollisionSetup; }}
      * @memberof InverseKinematicsRequest
      */
-    'collision_scenes'?: { [key: string]: SingleMotionGroupCollisionScene; };
+    'collision_setups'?: { [key: string]: CollisionSetup; };
 }
 /**
  * 
@@ -2003,6 +2154,50 @@ export interface InverseKinematicsResponse {
      */
     'joints': Array<Array<Array<number>>>;
 }
+/**
+ * 
+ * @export
+ * @interface InverseKinematicsValidationError
+ */
+export interface InverseKinematicsValidationError {
+    /**
+     * 
+     * @type {Array<ValidationErrorLocInner>}
+     * @memberof InverseKinematicsValidationError
+     */
+    'loc': Array<ValidationErrorLocInner>;
+    /**
+     * 
+     * @type {string}
+     * @memberof InverseKinematicsValidationError
+     */
+    'msg': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof InverseKinematicsValidationError
+     */
+    'type': string;
+    /**
+     * 
+     * @type {{ [key: string]: any; }}
+     * @memberof InverseKinematicsValidationError
+     */
+    'input': { [key: string]: any; };
+    /**
+     * 
+     * @type {InverseKinematicsValidationErrorAllOfData}
+     * @memberof InverseKinematicsValidationError
+     */
+    'data'?: InverseKinematicsValidationErrorAllOfData;
+}
+/**
+ * @type InverseKinematicsValidationErrorAllOfData
+ * Optional data further specifying the validation error. 
+ * @export
+ */
+export type InverseKinematicsValidationErrorAllOfData = { error_feedback_name: 'ErrorInvalidJointCount' } & ErrorInvalidJointCount | { error_feedback_name: 'ErrorJointLimitExceeded' } & ErrorJointLimitExceeded;
+
 /**
  * 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
@@ -2033,45 +2228,157 @@ export type JoggingDetailsKindEnum = typeof JoggingDetailsKindEnum[keyof typeof
  * @type JoggingDetailsState
  * @export
  */
-export type JoggingDetailsState = PausedByUser | PausedNearCollision | PausedNearJointLimit | PausedOnIO | Running;
+export type JoggingDetailsState = JoggingPausedByUser | JoggingPausedNearCollision | JoggingPausedNearJointLimit | JoggingPausedOnIO | JoggingRunning;
 
 /**
  * 
  * @export
- * @interface JointLimitExceeded
+ * @interface JoggingPausedByUser
  */
-export interface JointLimitExceeded {
+export interface JoggingPausedByUser {
     /**
      * 
-     * @type {FeedbackJointLimitExceeded}
-     * @memberof JointLimitExceeded
+     * @type {string}
+     * @memberof JoggingPausedByUser
      */
-    'joint_limit_exceeded'?: FeedbackJointLimitExceeded;
+    'kind': JoggingPausedByUserKindEnum;
 }
+
+export const JoggingPausedByUserKindEnum = {
+    PausedByUser: 'PAUSED_BY_USER'
+} as const;
+
+export type JoggingPausedByUserKindEnum = typeof JoggingPausedByUserKindEnum[keyof typeof JoggingPausedByUserKindEnum];
+
 /**
  * 
  * @export
- * @interface JointLimits
+ * @interface JoggingPausedNearCollision
  */
-export interface JointLimits {
-    /**
-     * 
-     * @type {LimitRange}
-     * @memberof JointLimits
-     */
-    'position'?: LimitRange;
+export interface JoggingPausedNearCollision {
     /**
      * 
-     * @type {number}
-     * @memberof JointLimits
+     * @type {string}
+     * @memberof JoggingPausedNearCollision
      */
-    'velocity'?: number;
+    'kind': JoggingPausedNearCollisionKindEnum;
     /**
      * 
-     * @type {number}
-     * @memberof JointLimits
+     * @type {string}
+     * @memberof JoggingPausedNearCollision
      */
-    'acceleration'?: number;
+    'description': string;
+}
+
+export const JoggingPausedNearCollisionKindEnum = {
+    PausedNearCollision: 'PAUSED_NEAR_COLLISION'
+} as const;
+
+export type JoggingPausedNearCollisionKindEnum = typeof JoggingPausedNearCollisionKindEnum[keyof typeof JoggingPausedNearCollisionKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface JoggingPausedNearJointLimit
+ */
+export interface JoggingPausedNearJointLimit {
+    /**
+     * 
+     * @type {string}
+     * @memberof JoggingPausedNearJointLimit
+     */
+    'kind': JoggingPausedNearJointLimitKindEnum;
+    /**
+     * 
+     * @type {Array<number>}
+     * @memberof JoggingPausedNearJointLimit
+     */
+    'joint_indices': Array<number>;
+}
+
+export const JoggingPausedNearJointLimitKindEnum = {
+    PausedNearJointLimit: 'PAUSED_NEAR_JOINT_LIMIT'
+} as const;
+
+export type JoggingPausedNearJointLimitKindEnum = typeof JoggingPausedNearJointLimitKindEnum[keyof typeof JoggingPausedNearJointLimitKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface JoggingPausedOnIO
+ */
+export interface JoggingPausedOnIO {
+    /**
+     * 
+     * @type {string}
+     * @memberof JoggingPausedOnIO
+     */
+    'kind': JoggingPausedOnIOKindEnum;
+}
+
+export const JoggingPausedOnIOKindEnum = {
+    PausedOnIo: 'PAUSED_ON_IO'
+} as const;
+
+export type JoggingPausedOnIOKindEnum = typeof JoggingPausedOnIOKindEnum[keyof typeof JoggingPausedOnIOKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface JoggingRunning
+ */
+export interface JoggingRunning {
+    /**
+     * 
+     * @type {string}
+     * @memberof JoggingRunning
+     */
+    'kind': JoggingRunningKindEnum;
+}
+
+export const JoggingRunningKindEnum = {
+    Running: 'RUNNING'
+} as const;
+
+export type JoggingRunningKindEnum = typeof JoggingRunningKindEnum[keyof typeof JoggingRunningKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface JointLimitExceeded
+ */
+export interface JointLimitExceeded {
+    /**
+     * 
+     * @type {FeedbackJointLimitExceeded}
+     * @memberof JointLimitExceeded
+     */
+    'joint_limit_exceeded'?: FeedbackJointLimitExceeded;
+}
+/**
+ * 
+ * @export
+ * @interface JointLimits
+ */
+export interface JointLimits {
+    /**
+     * 
+     * @type {LimitRange}
+     * @memberof JointLimits
+     */
+    'position'?: LimitRange;
+    /**
+     * 
+     * @type {number}
+     * @memberof JointLimits
+     */
+    'velocity'?: number;
+    /**
+     * 
+     * @type {number}
+     * @memberof JointLimits
+     */
+    'acceleration'?: number;
     /**
      * 
      * @type {number}
@@ -2473,6 +2780,32 @@ export const Manufacturer = {
 export type Manufacturer = typeof Manufacturer[keyof typeof Manufacturer];
 
 
+/**
+ * Midpoint insertion algorithm configuration for collision-free path planning. This algorithm iteratively inserts midpoints between the start and target joint position to find collision-free paths. 
+ * @export
+ * @interface MidpointInsertionAlgorithm
+ */
+export interface MidpointInsertionAlgorithm {
+    /**
+     * Algorithm discriminator. 
+     * @type {string}
+     * @memberof MidpointInsertionAlgorithm
+     */
+    'algorithm_name': MidpointInsertionAlgorithmAlgorithmNameEnum;
+    /**
+     * Maximum number of iterations for the midpoint insertion algorithm. Higher values increase likelyhood of success, but also computation time (linear). 
+     * @type {number}
+     * @memberof MidpointInsertionAlgorithm
+     */
+    'max_iterations'?: number;
+}
+
+export const MidpointInsertionAlgorithmAlgorithmNameEnum = {
+    MidpointInsertionAlgorithm: 'MidpointInsertionAlgorithm'
+} as const;
+
+export type MidpointInsertionAlgorithmAlgorithmNameEnum = typeof MidpointInsertionAlgorithmAlgorithmNameEnum[keyof typeof MidpointInsertionAlgorithmAlgorithmNameEnum];
+
 /**
  * 
  * @export
@@ -2653,6 +2986,55 @@ export interface MotionGroupJoints {
      */
     'torques'?: Array<number>;
 }
+/**
+ * 
+ * @export
+ * @interface MotionGroupSetup
+ */
+export interface MotionGroupSetup {
+    /**
+     * String identifiying the model of a motion group.
+     * @type {string}
+     * @memberof MotionGroupSetup
+     */
+    'motion_group_model': string;
+    /**
+     * [ms] cycle time of the motion group controller. A trajectory for this motion group should be computed to this resolution.
+     * @type {number}
+     * @memberof MotionGroupSetup
+     */
+    'cycle_time': number;
+    /**
+     * The offset from the world frame to the motion group base.
+     * @type {Pose}
+     * @memberof MotionGroupSetup
+     */
+    'mounting'?: Pose;
+    /**
+     * 
+     * @type {Pose}
+     * @memberof MotionGroupSetup
+     */
+    'tcp_offset'?: Pose;
+    /**
+     * 
+     * @type {LimitSet}
+     * @memberof MotionGroupSetup
+     */
+    'global_limits'?: LimitSet;
+    /**
+     * 
+     * @type {Payload}
+     * @memberof MotionGroupSetup
+     */
+    'payload'?: Payload;
+    /**
+     * Collision layers to be respected by the motion planner when planning for a single motion group. Each setup represents one layer, e.g. the safety zones and shapes or a fine grained tool and workpiece model. Layers are checked individually along the trajectory and independently of other layers.  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 layer. 3. Create other layers from your own 3D data as needed. 4. Plan trajectory. 5. The response highlights the layer in which a collision was detected by key. 
+     * @type {{ [key: string]: CollisionSetup; }}
+     * @memberof MotionGroupSetup
+     */
+    'collision_setups'?: { [key: string]: CollisionSetup; };
+}
 /**
  * Presents the current state of the motion group.
  * @export
@@ -3187,146 +3569,110 @@ export interface PauseOnIO {
 /**
  * 
  * @export
- * @interface PausedByRequest
+ * @interface Payload
  */
-export interface PausedByRequest {
+export interface Payload {
     /**
      * 
      * @type {string}
-     * @memberof PausedByRequest
+     * @memberof Payload
+     */
+    'name': string;
+    /**
+     * Mass of payload in [kg].
+     * @type {number}
+     * @memberof Payload
+     */
+    'payload': number;
+    /**
+     * A three-dimensional vector [x, y, z] with double precision. 
+     * @type {Array<number>}
+     * @memberof Payload
+     */
+    'center_of_mass'?: Array<number>;
+    /**
+     * A three-dimensional vector [x, y, z] with double precision. 
+     * @type {Array<number>}
+     * @memberof Payload
      */
-    'kind': PausedByRequestKindEnum;
+    'moment_of_inertia'?: Array<number>;
 }
-
-export const PausedByRequestKindEnum = {
-    PausedByUser: 'PAUSED_BY_USER'
-} as const;
-
-export type PausedByRequestKindEnum = typeof PausedByRequestKindEnum[keyof typeof PausedByRequestKindEnum];
-
 /**
  * 
  * @export
- * @interface PausedByUser
+ * @interface Plan422Response
  */
-export interface PausedByUser {
+export interface Plan422Response {
     /**
      * 
-     * @type {string}
-     * @memberof PausedByUser
+     * @type {Array<PlanValidationError>}
+     * @memberof Plan422Response
      */
-    'kind': PausedByUserKindEnum;
+    'detail'?: Array<PlanValidationError>;
 }
-
-export const PausedByUserKindEnum = {
-    PausedByUser: 'PAUSED_BY_USER'
-} as const;
-
-export type PausedByUserKindEnum = typeof PausedByUserKindEnum[keyof typeof PausedByUserKindEnum];
-
 /**
- * 
+ * Response when collision-free trajectory planning fails. Contains specific feedback about why the planning failed. 
  * @export
- * @interface PausedNearCollision
+ * @interface PlanCollisionFreeFailedResponse
  */
-export interface PausedNearCollision {
+export interface PlanCollisionFreeFailedResponse {
     /**
      * 
-     * @type {string}
-     * @memberof PausedNearCollision
+     * @type {ErrorMaxIterationsExceeded}
+     * @memberof PlanCollisionFreeFailedResponse
      */
-    'kind': PausedNearCollisionKindEnum;
-    /**
-     * 
-     * @type {string}
-     * @memberof PausedNearCollision
-     */
-    'description': string;
+    'error_feedback': ErrorMaxIterationsExceeded;
 }
-
-export const PausedNearCollisionKindEnum = {
-    PausedNearCollision: 'PAUSED_NEAR_COLLISION'
-} as const;
-
-export type PausedNearCollisionKindEnum = typeof PausedNearCollisionKindEnum[keyof typeof PausedNearCollisionKindEnum];
-
 /**
  * 
  * @export
- * @interface PausedNearJointLimit
+ * @interface PlanCollisionFreeRequest
  */
-export interface PausedNearJointLimit {
+export interface PlanCollisionFreeRequest {
+    /**
+     * The data to assemble the robot setup can be retrieved from [getMotionGroupDescription](getMotionGroupDescription) endpoint.
+     * @type {MotionGroupSetup}
+     * @memberof PlanCollisionFreeRequest
+     */
+    'motion_group_setup': MotionGroupSetup;
     /**
      * 
-     * @type {string}
-     * @memberof PausedNearJointLimit
+     * @type {Array<number>}
+     * @memberof PlanCollisionFreeRequest
      */
-    'kind': PausedNearJointLimitKindEnum;
+    'start_joint_position': Array<number>;
     /**
      * 
      * @type {Array<number>}
-     * @memberof PausedNearJointLimit
+     * @memberof PlanCollisionFreeRequest
      */
-    '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 {
+    'target': Array<number>;
     /**
      * 
-     * @type {string}
-     * @memberof PausedOnIO
+     * @type {CollisionFreeAlgorithm}
+     * @memberof PlanCollisionFreeRequest
      */
-    'kind': PausedOnIOKindEnum;
+    'algorithm': CollisionFreeAlgorithm;
 }
-
-export const PausedOnIOKindEnum = {
-    PausedOnIo: 'PAUSED_ON_IO'
-} as const;
-
-export type PausedOnIOKindEnum = typeof PausedOnIOKindEnum[keyof typeof PausedOnIOKindEnum];
-
 /**
- * 
+ * Response from collision-free trajectory planning. Contains either a successful joint trajectory or failure information. 
  * @export
- * @interface Payload
+ * @interface PlanCollisionFreeResponse
  */
-export interface Payload {
+export interface PlanCollisionFreeResponse {
     /**
      * 
-     * @type {string}
-     * @memberof Payload
+     * @type {PlanCollisionFreeResponseResponse}
+     * @memberof PlanCollisionFreeResponse
      */
-    'name': string;
-    /**
-     * Mass of payload in [kg].
-     * @type {number}
-     * @memberof Payload
-     */
-    'payload': number;
-    /**
-     * A three-dimensional vector [x, y, z] with double precision. 
-     * @type {Array<number>}
-     * @memberof Payload
-     */
-    'center_of_mass'?: Array<number>;
-    /**
-     * A three-dimensional vector [x, y, z] with double precision. 
-     * @type {Array<number>}
-     * @memberof Payload
-     */
-    'moment_of_inertia'?: Array<number>;
+    'response': PlanCollisionFreeResponseResponse;
 }
+/**
+ * @type PlanCollisionFreeResponseResponse
+ * @export
+ */
+export type PlanCollisionFreeResponseResponse = JointTrajectory | PlanCollisionFreeFailedResponse;
+
 /**
  * 
  * @export
@@ -3366,10 +3712,10 @@ export type PlanTrajectoryFailedResponseErrorFeedback = FeedbackCollision | Feed
 export interface PlanTrajectoryRequest {
     /**
      * The data to assemble the robot setup can be retrieved from [getMotionGroupDescription](getMotionGroupDescription) endpoint.
-     * @type {RobotSetup}
+     * @type {MotionGroupSetup}
      * @memberof PlanTrajectoryRequest
      */
-    'robot_setup': RobotSetup;
+    'motion_group_setup': MotionGroupSetup;
     /**
      * 
      * @type {Array<number>}
@@ -3402,6 +3748,50 @@ export interface PlanTrajectoryResponse {
  */
 export type PlanTrajectoryResponseResponse = JointTrajectory | PlanTrajectoryFailedResponse;
 
+/**
+ * 
+ * @export
+ * @interface PlanValidationError
+ */
+export interface PlanValidationError {
+    /**
+     * 
+     * @type {Array<ValidationErrorLocInner>}
+     * @memberof PlanValidationError
+     */
+    'loc': Array<ValidationErrorLocInner>;
+    /**
+     * 
+     * @type {string}
+     * @memberof PlanValidationError
+     */
+    'msg': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof PlanValidationError
+     */
+    'type': string;
+    /**
+     * 
+     * @type {{ [key: string]: any; }}
+     * @memberof PlanValidationError
+     */
+    'input': { [key: string]: any; };
+    /**
+     * 
+     * @type {PlanValidationErrorAllOfData}
+     * @memberof PlanValidationError
+     */
+    'data'?: PlanValidationErrorAllOfData;
+}
+/**
+ * @type PlanValidationErrorAllOfData
+ * Optional data further specifying the validation error. 
+ * @export
+ */
+export type PlanValidationErrorAllOfData = { error_feedback_name: 'ErrorInvalidJointCount' } & ErrorInvalidJointCount | { error_feedback_name: 'ErrorJointLimitExceeded' } & ErrorJointLimitExceeded | { error_feedback_name: 'ErrorJointPositionCollision' } & ErrorJointPositionCollision;
+
 /**
  * Defines an x/y-plane with infinite size.
  * @export
@@ -3493,6 +3883,32 @@ export interface Pose {
      */
     'orientation'?: Array<number>;
 }
+/**
+ * <!-- theme: danger -->  > **Experimental**  RRT Connect algorithm configuration for collision-free path planning. Rapidly-exploring Random Trees (RRT) builds trees of valid configurations by randomly sampling the joint space and connecting feasible points. RRT Connect grows two trees simultaneously from start and target positions until they meet. This is a custom implementation optimized for manipulator kinematics and collision checking in industrial contexts. 
+ * @export
+ * @interface RRTConnectAlgorithm
+ */
+export interface RRTConnectAlgorithm {
+    /**
+     * Algorithm discriminator. 
+     * @type {string}
+     * @memberof RRTConnectAlgorithm
+     */
+    'algorithm_name': RRTConnectAlgorithmAlgorithmNameEnum;
+    /**
+     * Maximum number of iterations for the RRT Connect algorithm. Higher values increase likelihood of success, but also computation time. 
+     * @type {number}
+     * @memberof RRTConnectAlgorithm
+     */
+    'max_iterations'?: number;
+}
+
+export const RRTConnectAlgorithmAlgorithmNameEnum = {
+    RrtConnectAlgorithm: 'RRTConnectAlgorithm'
+} as const;
+
+export type RRTConnectAlgorithmAlgorithmNameEnum = typeof RRTConnectAlgorithmAlgorithmNameEnum[keyof typeof RRTConnectAlgorithmAlgorithmNameEnum];
+
 /**
  * Defines an x/y-plane with finite size. Centred around the z-axis.
  * @export
@@ -3584,7 +4000,7 @@ export type ReleaseChannel = typeof ReleaseChannel[keyof typeof ReleaseChannel];
  */
 export interface RobotController {
     /**
-     * A unique name of the Controller inside the Cell. It must be a valid k8s label name as defined by [RFC 1035](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#rfc-1035-label-names).
+     * Unique name of controller within the cell. It must be a valid k8s label name as defined by [RFC 1035](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#rfc-1035-label-names). 
      * @type {string}
      * @memberof RobotController
      */
@@ -3608,6 +4024,18 @@ export type RobotControllerConfiguration = AbbController | FanucController | Kuk
  * @interface RobotControllerState
  */
 export interface RobotControllerState {
+    /**
+     * Mode of communication and control between NOVA and the robot controller.
+     * @type {RobotSystemMode}
+     * @memberof RobotControllerState
+     */
+    'mode': RobotSystemMode;
+    /**
+     * Last error stack encountered during initialization process or after a controller disconnect. At this stage, it\'s unclear whether the error is fatal.  Evaluate `last_error` to decide whether to remove the controller using `deleteController`. Examples: - Delete required: Host resolution fails repeatedly due to an incorrect IP. - Delete not required: Temporary network delay caused a disconnect; the system will auto-reconnect. 
+     * @type {Array<string>}
+     * @memberof RobotControllerState
+     */
+    'last_error'?: Array<string>;
     /**
      * Timestamp indicating when the represented information was received from the robot controller.
      * @type {string}
@@ -3654,66 +4082,17 @@ export interface RobotControllerState {
 
 
 /**
- * 
- * @export
- * @interface RobotSetup
- */
-export interface RobotSetup {
-    /**
-     * String identifiying the model of a motion group.
-     * @type {string}
-     * @memberof RobotSetup
-     */
-    'motion_group_model': string;
-    /**
-     * [ms] cycle time of the motion group controller. A trajectory for this motion group should be computed to this resolution.
-     * @type {number}
-     * @memberof RobotSetup
-     */
-    'cycle_time': number;
-    /**
-     * The offset from the world frame to the motion group base.
-     * @type {Pose}
-     * @memberof RobotSetup
-     */
-    'mounting'?: Pose;
-    /**
-     * 
-     * @type {Pose}
-     * @memberof RobotSetup
-     */
-    'tcp_offset'?: Pose;
-    /**
-     * 
-     * @type {LimitSet}
-     * @memberof RobotSetup
-     */
-    'global_limits'?: LimitSet;
-    /**
-     * 
-     * @type {Payload}
-     * @memberof RobotSetup
-     */
-    'payload'?: Payload;
-    /**
-     * 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; }}
-     * @memberof RobotSetup
-     */
-    'collision_scenes'?: { [key: string]: SingleMotionGroupCollisionScene; };
-}
-/**
- * The system mode of the robot system.  ### ROBOT_SYSTEM_MODE_UNDEFINED  Indicates that the robot controller is currently performing a mode transition.  ### ROBOT_SYSTEM_MODE_DISCONNECT  There is no communication with the robot controller at all. All connections are closed. No command is sent to the robot controller while in this mode. No input/output interaction is possible in this mode! All move requests will be rejected in this mode!  ### ROBOT_SYSTEM_MODE_MONITOR  A connection to the robot controller is established to only read the robot controller state. No command is sent to the robot controller while in this mode. It is possible to receive input/output information. All move requests will be rejected in this mode!  ### ROBOT_SYSTEM_MODE_CONTROL  An active connection is established with the robot controller and the robot system is cyclic commanded to stay in its actual position. The robot controller state is received in the cycle time of the robot controller. Requests via the MotionService and JoggingService will be processed and executed in this mode. Input/Output interaction is possible in this mode! **In this mode the robot system can be commanded to move.**  ### ROBOT_SYSTEM_MODE_FREE_DRIVE  Like ROBOT_SYSTEM_MODE_MONITOR a connection to the robot controller is established to only read the robot controller state. The difference is that the motion groups can be moved by the user (Free Drive). Thus, the servo motors are turned on. All move requests will be rejected in this mode! **This mode is not supported by every robot!** Use [getSupportedModes](getSupportedModes) to evaluate if the device support free drive. 
+ * Defines the current system mode of the robot system, including NOVA communicating with the robot controller.  ### MODE_CONTROLLER_NOT_CONFIGURED  No controller with the specified identifier is configured. Call [addRobotController](addRobotController) to register a controller.  ### MODE_INITIALIZING  Indicates that a connection to the robot controller is established or reestablished in case of a disconnect. On success, the controller is set to MODE_MONITOR. On failure, the initialization process is retried until successful or cancelled by the user.  ### MODE_MONITOR  Read-only mode with an active controller connection. - Receives robot state and I/O signals - Move requests are rejected - No commands are sent to the controller  ### MODE_CONTROL  Active control mode.  **Movement is possible in this mode**  The robot is cyclically commanded to hold its current position. The robot state is received in sync with the controller cycle. Motion and jogging requests are accepted and executed. Input/Output interaction is enabled.  ### MODE_FREE_DRIVE  Read-only mode with servo motors enabled for manual movement (Free Drive).  Move requests are rejected.  Not supported by all robots: Use [getSupportedModes](getSupportedModes) to check Free Drive availability. 
  * @export
  * @enum {string}
  */
 
 export const RobotSystemMode = {
-    RobotSystemModeUndefined: 'ROBOT_SYSTEM_MODE_UNDEFINED',
-    RobotSystemModeDisconnect: 'ROBOT_SYSTEM_MODE_DISCONNECT',
-    RobotSystemModeMonitor: 'ROBOT_SYSTEM_MODE_MONITOR',
-    RobotSystemModeControl: 'ROBOT_SYSTEM_MODE_CONTROL',
-    RobotSystemModeFreeDrive: 'ROBOT_SYSTEM_MODE_FREE_DRIVE'
+    ModeControllerNotConfigured: 'MODE_CONTROLLER_NOT_CONFIGURED',
+    ModeInitializing: 'MODE_INITIALIZING',
+    ModeMonitor: 'MODE_MONITOR',
+    ModeControl: 'MODE_CONTROL',
+    ModeFreeDrive: 'MODE_FREE_DRIVE'
 } as const;
 
 export type RobotSystemMode = typeof RobotSystemMode[keyof typeof RobotSystemMode];
@@ -3791,52 +4170,6 @@ export interface RobotTcpData {
 }
 
 
-/**
- * 
- * @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
@@ -4011,37 +4344,6 @@ export const SettableRobotSystemMode = {
 export type SettableRobotSystemMode = typeof SettableRobotSystemMode[keyof typeof SettableRobotSystemMode];
 
 
-/**
- * 
- * @export
- * @interface SingleMotionGroupCollisionScene
- */
-export interface SingleMotionGroupCollisionScene {
-    /**
-     * A collection of identifiable colliders.
-     * @type {{ [key: string]: Collider; }}
-     * @memberof SingleMotionGroupCollisionScene
-     */
-    'static_colliders'?: { [key: string]: Collider; };
-    /**
-     * A link chain is a kinematic chain of links that is connected via joints. A motion group can be used to control the motion of the joints in a link chain.  A link is a group of colliders that is attached to the link reference frame.  The reference frame of a link is obtained after applying all sets of Denavit-Hartenberg-parameters from base to (including) the link index.  This means that the reference frame of the link is on the rotation axis of the next joint in the kinematic chain. Example: For a motion group with 2 joints, the collider reference frame (CRF) for link 1 is on the rotation axis of joint 2. The chain looks like: - Origin >> Mounting >> Base >> (CRF Base) Joint 0 >> Link 0 >> (CRF Link 0) Joint 1 >> Link 1 >> (CRF Link 1) Flange (CRF Tool) >> TCP  Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. 
-     * @type {Array<{ [key: string]: Collider; }>}
-     * @memberof SingleMotionGroupCollisionScene
-     */
-    'link_chain'?: Array<{ [key: string]: Collider; }>;
-    /**
-     * Defines the shape of a tool.  A tool is a dictionary of colliders.  All colliders that make up a tool are attached to the flange frame of the motion group. 
-     * @type {{ [key: string]: Collider; }}
-     * @memberof SingleMotionGroupCollisionScene
-     */
-    'tool'?: { [key: string]: Collider; };
-    /**
-     * If true, self-collision detection is enabled for the motion group. See LinkChain documentation for details. Default is true. 
-     * @type {boolean}
-     * @memberof SingleMotionGroupCollisionScene
-     */
-    'motion_group_self_collision_detection'?: boolean;
-}
 /**
  * 
  * @export
@@ -4100,7 +4402,7 @@ export interface StartMovementRequest {
      * @type {Direction}
      * @memberof StartMovementRequest
      */
-    'direction': Direction;
+    'direction'?: Direction;
     /**
      * Attaches a list of output commands to the trajectory. The outputs are set to the specified values right after the specified location was reached. If the specified location is located before the start location (forward direction: value is smaller, backward direction: value is bigger), the output is not set. 
      * @type {Array<IOValue>}
@@ -4390,50 +4692,156 @@ export interface TrajectoryDetails {
      */
     'state': TrajectoryDetailsState;
     /**
-     * Discriminator for OpenApi generators, which is always \"TRAJECTORY\" for this schema. 
+     * 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 = TrajectoryEnded | TrajectoryPausedByUser | TrajectoryPausedOnIO | TrajectoryRunning | TrajectoryWaitForIO;
+
+/**
+ * 
+ * @export
+ * @interface TrajectoryEnded
+ */
+export interface TrajectoryEnded {
+    /**
+     * 
+     * @type {string}
+     * @memberof TrajectoryEnded
+     */
+    'kind': TrajectoryEndedKindEnum;
+}
+
+export const TrajectoryEndedKindEnum = {
+    EndOfTrajectory: 'END_OF_TRAJECTORY'
+} as const;
+
+export type TrajectoryEndedKindEnum = typeof TrajectoryEndedKindEnum[keyof typeof TrajectoryEndedKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface TrajectoryId
+ */
+export interface TrajectoryId {
+    /**
+     * Type specifier for server, set automatically. 
+     * @type {string}
+     * @memberof TrajectoryId
+     */
+    'message_type'?: TrajectoryIdMessageTypeEnum;
+    /**
+     * The identifier of the trajectory which was returned by the [addTrajectory](addTrajectory) endpoint. 
+     * @type {string}
+     * @memberof TrajectoryId
+     */
+    'id': string;
+}
+
+export const TrajectoryIdMessageTypeEnum = {
+    TrajectoryId: 'TrajectoryId'
+} as const;
+
+export type TrajectoryIdMessageTypeEnum = typeof TrajectoryIdMessageTypeEnum[keyof typeof TrajectoryIdMessageTypeEnum];
+
+/**
+ * 
+ * @export
+ * @interface TrajectoryPausedByUser
+ */
+export interface TrajectoryPausedByUser {
+    /**
+     * 
+     * @type {string}
+     * @memberof TrajectoryPausedByUser
+     */
+    'kind': TrajectoryPausedByUserKindEnum;
+}
+
+export const TrajectoryPausedByUserKindEnum = {
+    PausedByUser: 'PAUSED_BY_USER'
+} as const;
+
+export type TrajectoryPausedByUserKindEnum = typeof TrajectoryPausedByUserKindEnum[keyof typeof TrajectoryPausedByUserKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface TrajectoryPausedOnIO
+ */
+export interface TrajectoryPausedOnIO {
+    /**
+     * 
      * @type {string}
-     * @memberof TrajectoryDetails
+     * @memberof TrajectoryPausedOnIO
      */
-    'kind': TrajectoryDetailsKindEnum;
+    'kind': TrajectoryPausedOnIOKindEnum;
 }
 
-export const TrajectoryDetailsKindEnum = {
-    Trajectory: 'TRAJECTORY'
+export const TrajectoryPausedOnIOKindEnum = {
+    PausedOnIo: 'PAUSED_ON_IO'
 } as const;
 
-export type TrajectoryDetailsKindEnum = typeof TrajectoryDetailsKindEnum[keyof typeof TrajectoryDetailsKindEnum];
+export type TrajectoryPausedOnIOKindEnum = typeof TrajectoryPausedOnIOKindEnum[keyof typeof TrajectoryPausedOnIOKindEnum];
 
 /**
- * @type TrajectoryDetailsState
+ * 
  * @export
+ * @interface TrajectoryRunning
  */
-export type TrajectoryDetailsState = EndOfTrajectory | PausedByRequest | PausedOnIO | Running1 | WaitForIO;
+export interface TrajectoryRunning {
+    /**
+     * 
+     * @type {string}
+     * @memberof TrajectoryRunning
+     */
+    'kind': TrajectoryRunningKindEnum;
+    /**
+     * Remaining time in milliseconds (ms) to reach the end of the motion.
+     * @type {number}
+     * @memberof TrajectoryRunning
+     */
+    'time_to_end': number;
+}
+
+export const TrajectoryRunningKindEnum = {
+    Running: 'RUNNING'
+} as const;
+
+export type TrajectoryRunningKindEnum = typeof TrajectoryRunningKindEnum[keyof typeof TrajectoryRunningKindEnum];
 
 /**
  * 
  * @export
- * @interface TrajectoryId
+ * @interface TrajectoryWaitForIO
  */
-export interface TrajectoryId {
-    /**
-     * Type specifier for server, set automatically. 
-     * @type {string}
-     * @memberof TrajectoryId
-     */
-    'message_type'?: TrajectoryIdMessageTypeEnum;
+export interface TrajectoryWaitForIO {
     /**
-     * The identifier of the trajectory which was returned by the [addTrajectory](addTrajectory) endpoint. 
+     * 
      * @type {string}
-     * @memberof TrajectoryId
+     * @memberof TrajectoryWaitForIO
      */
-    'id': string;
+    'kind': TrajectoryWaitForIOKindEnum;
 }
 
-export const TrajectoryIdMessageTypeEnum = {
-    TrajectoryId: 'TrajectoryId'
+export const TrajectoryWaitForIOKindEnum = {
+    WaitForIo: 'WAIT_FOR_IO'
 } as const;
 
-export type TrajectoryIdMessageTypeEnum = typeof TrajectoryIdMessageTypeEnum[keyof typeof TrajectoryIdMessageTypeEnum];
+export type TrajectoryWaitForIOKindEnum = typeof TrajectoryWaitForIOKindEnum[keyof typeof TrajectoryWaitForIOKindEnum];
 
 /**
  * The unit of input/output value.
@@ -4522,6 +4930,12 @@ export interface ValidationError {
      * @memberof ValidationError
      */
     'type': string;
+    /**
+     * 
+     * @type {{ [key: string]: any; }}
+     * @memberof ValidationError
+     */
+    'input': { [key: string]: any; };
 }
 /**
  * @type ValidationErrorLocInner
@@ -4564,7 +4978,7 @@ export interface VirtualController {
      * @type {string}
      * @memberof VirtualController
      */
-    'position'?: string;
+    'initial_joint_position'?: string;
 }
 
 export const VirtualControllerKindEnum = {
@@ -4614,6 +5028,7 @@ export const VirtualControllerTypes = {
     FanucCrx20ial: 'fanuc-crx20ial',
     FanucCrx25ia: 'fanuc-crx25ia',
     FanucCrx30ia: 'fanuc-crx30ia',
+    FanucCrx5ia: 'fanuc-crx5ia',
     FanucLrMate200iD: 'fanuc-lr_mate_200iD',
     FanucLrMate200iD4S: 'fanuc-lr_mate_200iD4S',
     FanucLrMate200iD7L: 'fanuc-lr_mate_200iD7L',
@@ -4621,6 +5036,7 @@ export const VirtualControllerTypes = {
     FanucM10iD16S: 'fanuc-m10iD16S',
     FanucM20iD25: 'fanuc-m20iD25',
     FanucM20iD35: 'fanuc-m20iD35',
+    FanucM710iC20L: 'fanuc-m710iC20L',
     FanucM900iB280L: 'fanuc-m900iB280L',
     FanucM900iB360E: 'fanuc-m900iB360E',
     FanucR2000ic125l: 'fanuc-r2000ic125l',
@@ -4711,26 +5127,6 @@ 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
@@ -4786,7 +5182,7 @@ export type YaskawaControllerKindEnum = typeof YaskawaControllerKindEnum[keyof t
 export const ApplicationApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
         /**
-         * Install a basic, containerized web application to the cell to control robots with a customized frontend.  Prerequisites: A Docker hub account or similar container registry account, with valid credentials.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The endpoint where the API is reachable from the container serving the Application. > - `BASE_PATH`: The root path of the deployed Application. It will be reachable via: http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell where the application is deployed. 
+         * Install a basic, containerized web application to the cell to control robots with a customized frontend.  Prerequisites: A Docker hub account or similar container registry account, with valid credentials.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The API endpoint accessible from within the application container. > - `NATS_BROKER`: The NATS broker endpoint accessible from within the application container. > - `BASE_PATH`: The application\'s root path, accessible at http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell hosting the deployed application. 
          * @summary Add Application
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {App} app 
@@ -5092,7 +5488,7 @@ export const ApplicationApiFp = function(configuration?: Configuration) {
     const localVarAxiosParamCreator = ApplicationApiAxiosParamCreator(configuration)
     return {
         /**
-         * Install a basic, containerized web application to the cell to control robots with a customized frontend.  Prerequisites: A Docker hub account or similar container registry account, with valid credentials.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The endpoint where the API is reachable from the container serving the Application. > - `BASE_PATH`: The root path of the deployed Application. It will be reachable via: http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell where the application is deployed. 
+         * Install a basic, containerized web application to the cell to control robots with a customized frontend.  Prerequisites: A Docker hub account or similar container registry account, with valid credentials.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The API endpoint accessible from within the application container. > - `NATS_BROKER`: The NATS broker endpoint accessible from within the application container. > - `BASE_PATH`: The application\'s root path, accessible at http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell hosting the deployed application. 
          * @summary Add Application
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {App} app 
@@ -5189,7 +5585,7 @@ export const ApplicationApiFactory = function (configuration?: Configuration, ba
     const localVarFp = ApplicationApiFp(configuration)
     return {
         /**
-         * Install a basic, containerized web application to the cell to control robots with a customized frontend.  Prerequisites: A Docker hub account or similar container registry account, with valid credentials.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The endpoint where the API is reachable from the container serving the Application. > - `BASE_PATH`: The root path of the deployed Application. It will be reachable via: http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell where the application is deployed. 
+         * Install a basic, containerized web application to the cell to control robots with a customized frontend.  Prerequisites: A Docker hub account or similar container registry account, with valid credentials.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The API endpoint accessible from within the application container. > - `NATS_BROKER`: The NATS broker endpoint accessible from within the application container. > - `BASE_PATH`: The application\'s root path, accessible at http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell hosting the deployed application. 
          * @summary Add Application
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {App} app 
@@ -5268,7 +5664,7 @@ export const ApplicationApiFactory = function (configuration?: Configuration, ba
  */
 export class ApplicationApi extends BaseAPI {
     /**
-     * Install a basic, containerized web application to the cell to control robots with a customized frontend.  Prerequisites: A Docker hub account or similar container registry account, with valid credentials.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The endpoint where the API is reachable from the container serving the Application. > - `BASE_PATH`: The root path of the deployed Application. It will be reachable via: http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell where the application is deployed. 
+     * Install a basic, containerized web application to the cell to control robots with a customized frontend.  Prerequisites: A Docker hub account or similar container registry account, with valid credentials.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The API endpoint accessible from within the application container. > - `NATS_BROKER`: The NATS broker endpoint accessible from within the application container. > - `BASE_PATH`: The application\'s root path, accessible at http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell hosting the deployed application. 
      * @summary Add Application
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
      * @param {App} app 
@@ -6262,52 +6658,6 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
 
 
     
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState). 
-         * @summary Current Mode
-         * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} controller Unique identifier to address a controller in the cell.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getMode: async (cell: string, controller: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getMode', 'cell', cell)
-            // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getMode', 'controller', controller)
-            const localVarPath = `/cells/{cell}/controllers/{controller}/mode`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
-            const localVarHeaderParameter = {} as any;
-            const localVarQueryParameter = {} as any;
-
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration)
-
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration)
-
-
-    
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
@@ -6503,7 +6853,7 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
             };
         },
         /**
-         * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change. 
+         * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > `setDefaultMode` enables the robot controller to stay in control mode to keep the motors activated. > This allows for faster execution of sequential movements as no mode switches are required.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change. 
          * @summary Set Default Mode
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {string} controller Unique identifier to address a controller in the cell.
@@ -6607,15 +6957,16 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
             };
         },
         /**
-         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller. 
+         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.  The stream can be opened before the controller is registered. To register a controller, call [addRobotController](addRobotController).  While connecting, the stream sends initialization updates. Once the controller reaches `MODE_MONITOR`, it sends controller state updates. 
          * @summary Stream State
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {string} controller Unique identifier to address a controller in the cell.
          * @param {number} [responseRate] 
+         * @param {number} [addControllerTimeout] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        streamRobotControllerState: async (cell: string, controller: string, responseRate?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        streamRobotControllerState: async (cell: string, controller: string, responseRate?: number, addControllerTimeout?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
             assertParamExists('streamRobotControllerState', 'cell', cell)
             // verify required parameter 'controller' is not null or undefined
@@ -6646,6 +6997,10 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
                 localVarQueryParameter['response_rate'] = responseRate;
             }
 
+            if (addControllerTimeout !== undefined) {
+                localVarQueryParameter['add_controller_timeout'] = addControllerTimeout;
+            }
+
 
     
             setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -6812,20 +7167,6 @@ export const ControllerApiFp = function(configuration?: Configuration) {
             const localVarOperationServerBasePath = operationServerMap['ControllerApi.getCurrentRobotControllerState']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
-        /**
-         * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState). 
-         * @summary Current Mode
-         * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} controller Unique identifier to address a controller in the cell.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getMode(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GetModeResponse>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getMode(cell, controller, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ControllerApi.getMode']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
         /**
          * Get the configuration for a robot controller. 
          * @summary Robot Controller
@@ -6883,7 +7224,7 @@ export const ControllerApiFp = function(configuration?: Configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change. 
+         * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > `setDefaultMode` enables the robot controller to stay in control mode to keep the motors activated. > This allows for faster execution of sequential movements as no mode switches are required.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change. 
          * @summary Set Default Mode
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {string} controller Unique identifier to address a controller in the cell.
@@ -6913,16 +7254,17 @@ export const ControllerApiFp = function(configuration?: Configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller. 
+         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.  The stream can be opened before the controller is registered. To register a controller, call [addRobotController](addRobotController).  While connecting, the stream sends initialization updates. Once the controller reaches `MODE_MONITOR`, it sends controller state updates. 
          * @summary Stream State
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {string} controller Unique identifier to address a controller in the cell.
          * @param {number} [responseRate] 
+         * @param {number} [addControllerTimeout] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async streamRobotControllerState(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RobotControllerState>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.streamRobotControllerState(cell, controller, responseRate, options);
+        async streamRobotControllerState(cell: string, controller: string, responseRate?: number, addControllerTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RobotControllerState>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.streamRobotControllerState(cell, controller, responseRate, addControllerTimeout, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['ControllerApi.streamRobotControllerState']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -7023,17 +7365,6 @@ export const ControllerApiFactory = function (configuration?: Configuration, bas
         getCurrentRobotControllerState(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<RobotControllerState> {
             return localVarFp.getCurrentRobotControllerState(cell, controller, options).then((request) => request(axios, basePath));
         },
-        /**
-         * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState). 
-         * @summary Current Mode
-         * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} controller Unique identifier to address a controller in the cell.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getMode(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<GetModeResponse> {
-            return localVarFp.getMode(cell, controller, options).then((request) => request(axios, basePath));
-        },
         /**
          * Get the configuration for a robot controller. 
          * @summary Robot Controller
@@ -7079,7 +7410,7 @@ export const ControllerApiFactory = function (configuration?: Configuration, bas
             return localVarFp.listRobotControllers(cell, options).then((request) => request(axios, basePath));
         },
         /**
-         * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change. 
+         * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > `setDefaultMode` enables the robot controller to stay in control mode to keep the motors activated. > This allows for faster execution of sequential movements as no mode switches are required.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change. 
          * @summary Set Default Mode
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {string} controller Unique identifier to address a controller in the cell.
@@ -7103,16 +7434,17 @@ export const ControllerApiFactory = function (configuration?: Configuration, bas
             return localVarFp.streamFreeDrive(cell, controller, responseRate, options).then((request) => request(axios, basePath));
         },
         /**
-         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller. 
+         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.  The stream can be opened before the controller is registered. To register a controller, call [addRobotController](addRobotController).  While connecting, the stream sends initialization updates. Once the controller reaches `MODE_MONITOR`, it sends controller state updates. 
          * @summary Stream State
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {string} controller Unique identifier to address a controller in the cell.
          * @param {number} [responseRate] 
+         * @param {number} [addControllerTimeout] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        streamRobotControllerState(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): AxiosPromise<RobotControllerState> {
-            return localVarFp.streamRobotControllerState(cell, controller, responseRate, options).then((request) => request(axios, basePath));
+        streamRobotControllerState(cell: string, controller: string, responseRate?: number, addControllerTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise<RobotControllerState> {
+            return localVarFp.streamRobotControllerState(cell, controller, responseRate, addControllerTimeout, options).then((request) => request(axios, basePath));
         },
         /**
          * Update the configuration of a robot controller.  Reconfigure certain options of a robot controller, or deploy a specific container image of a robot controller.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior. 
@@ -7219,19 +7551,6 @@ export class ControllerApi extends BaseAPI {
         return ControllerApiFp(this.configuration).getCurrentRobotControllerState(cell, controller, options).then((request) => request(this.axios, this.basePath));
     }
 
-    /**
-     * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState). 
-     * @summary Current Mode
-     * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {string} controller Unique identifier to address a controller in the cell.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof ControllerApi
-     */
-    public getMode(cell: string, controller: string, options?: RawAxiosRequestConfig) {
-        return ControllerApiFp(this.configuration).getMode(cell, controller, options).then((request) => request(this.axios, this.basePath));
-    }
-
     /**
      * Get the configuration for a robot controller. 
      * @summary Robot Controller
@@ -7285,7 +7604,7 @@ export class ControllerApi extends BaseAPI {
     }
 
     /**
-     * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change. 
+     * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > `setDefaultMode` enables the robot controller to stay in control mode to keep the motors activated. > This allows for faster execution of sequential movements as no mode switches are required.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change. 
      * @summary Set Default Mode
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
      * @param {string} controller Unique identifier to address a controller in the cell.
@@ -7313,17 +7632,18 @@ export class ControllerApi extends BaseAPI {
     }
 
     /**
-     * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller. 
+     * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.  The stream can be opened before the controller is registered. To register a controller, call [addRobotController](addRobotController).  While connecting, the stream sends initialization updates. Once the controller reaches `MODE_MONITOR`, it sends controller state updates. 
      * @summary Stream State
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
      * @param {string} controller Unique identifier to address a controller in the cell.
      * @param {number} [responseRate] 
+     * @param {number} [addControllerTimeout] 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ControllerApi
      */
-    public streamRobotControllerState(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig) {
-        return ControllerApiFp(this.configuration).streamRobotControllerState(cell, controller, responseRate, options).then((request) => request(this.axios, this.basePath));
+    public streamRobotControllerState(cell: string, controller: string, responseRate?: number, addControllerTimeout?: number, options?: RawAxiosRequestConfig) {
+        return ControllerApiFp(this.configuration).streamRobotControllerState(cell, controller, responseRate, addControllerTimeout, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -8007,6 +8327,52 @@ export class JoggingApi extends BaseAPI {
  */
 export const KinematicsApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
+        /**
+         * Returns the TCP poses for a list of given joint positions. 
+         * @summary Forward kinematics
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {ForwardKinematicsRequest} [forwardKinematicsRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        forwardKinematics: async (cell: string, forwardKinematicsRequest?: ForwardKinematicsRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('forwardKinematics', 'cell', cell)
+            const localVarPath = `/cells/{cell}/kinematic/forward`
+                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication BasicAuth required
+            // http basic authentication required
+            setBasicAuthToObject(localVarRequestOptions, configuration)
+
+            // authentication BearerAuth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration)
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(forwardKinematicsRequest, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * Returns the reachable joint positions for a list of given poses. 
          * @summary Inverse kinematics
@@ -8063,6 +8429,20 @@ export const KinematicsApiAxiosParamCreator = function (configuration?: Configur
 export const KinematicsApiFp = function(configuration?: Configuration) {
     const localVarAxiosParamCreator = KinematicsApiAxiosParamCreator(configuration)
     return {
+        /**
+         * Returns the TCP poses for a list of given joint positions. 
+         * @summary Forward kinematics
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {ForwardKinematicsRequest} [forwardKinematicsRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async forwardKinematics(cell: string, forwardKinematicsRequest?: ForwardKinematicsRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ForwardKinematicsResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.forwardKinematics(cell, forwardKinematicsRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['KinematicsApi.forwardKinematics']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * Returns the reachable joint positions for a list of given poses. 
          * @summary Inverse kinematics
@@ -8087,6 +8467,17 @@ export const KinematicsApiFp = function(configuration?: Configuration) {
 export const KinematicsApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
     const localVarFp = KinematicsApiFp(configuration)
     return {
+        /**
+         * Returns the TCP poses for a list of given joint positions. 
+         * @summary Forward kinematics
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {ForwardKinematicsRequest} [forwardKinematicsRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        forwardKinematics(cell: string, forwardKinematicsRequest?: ForwardKinematicsRequest, options?: RawAxiosRequestConfig): AxiosPromise<ForwardKinematicsResponse> {
+            return localVarFp.forwardKinematics(cell, forwardKinematicsRequest, options).then((request) => request(axios, basePath));
+        },
         /**
          * Returns the reachable joint positions for a list of given poses. 
          * @summary Inverse kinematics
@@ -8108,6 +8499,19 @@ export const KinematicsApiFactory = function (configuration?: Configuration, bas
  * @extends {BaseAPI}
  */
 export class KinematicsApi extends BaseAPI {
+    /**
+     * Returns the TCP poses for a list of given joint positions. 
+     * @summary Forward kinematics
+     * @param {string} cell Unique identifier addressing a cell in all API calls. 
+     * @param {ForwardKinematicsRequest} [forwardKinematicsRequest] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof KinematicsApi
+     */
+    public forwardKinematics(cell: string, forwardKinematicsRequest?: ForwardKinematicsRequest, options?: RawAxiosRequestConfig) {
+        return KinematicsApiFp(this.configuration).forwardKinematics(cell, forwardKinematicsRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Returns the reachable joint positions for a list of given poses. 
      * @summary Inverse kinematics
@@ -10042,27 +10446,27 @@ export class StoreCollisionComponentsApi extends BaseAPI {
 
 
 /**
- * StoreCollisionScenesApi - axios parameter creator
+ * StoreCollisionSetupsApi - axios parameter creator
  * @export
  */
-export const StoreCollisionScenesApiAxiosParamCreator = function (configuration?: Configuration) {
+export const StoreCollisionSetupsApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
         /**
-         * Deletes the stored scene.  <!-- theme: danger --> > This will delete persistently stored data. 
-         * @summary Delete Scene
+         * Deletes the stored collision setup.  <!-- theme: danger --> > This will delete persistently stored data. 
+         * @summary Delete Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
+         * @param {string} setup Identifier of the collision setup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        deleteStoredCollisionScene: async (cell: string, scene: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        deleteStoredCollisionSetup: async (cell: string, setup: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('deleteStoredCollisionScene', 'cell', cell)
-            // verify required parameter 'scene' is not null or undefined
-            assertParamExists('deleteStoredCollisionScene', 'scene', scene)
-            const localVarPath = `/cells/{cell}/store/collision/scenes/{scene}`
+            assertParamExists('deleteStoredCollisionSetup', 'cell', cell)
+            // verify required parameter 'setup' is not null or undefined
+            assertParamExists('deleteStoredCollisionSetup', 'setup', setup)
+            const localVarPath = `/cells/{cell}/store/collision/setups/{setup}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"scene"}}`, encodeURIComponent(String(scene)));
+                .replace(`{${"setup"}}`, encodeURIComponent(String(setup)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -10094,21 +10498,21 @@ export const StoreCollisionScenesApiAxiosParamCreator = function (configuration?
             };
         },
         /**
-         * Returns the stored scene. 
-         * @summary Get Scene
+         * Returns the stored collision setup. 
+         * @summary Get Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
+         * @param {string} setup Identifier of the collision setup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getStoredCollisionScene: async (cell: string, scene: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        getStoredCollisionSetup: async (cell: string, setup: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getStoredCollisionScene', 'cell', cell)
-            // verify required parameter 'scene' is not null or undefined
-            assertParamExists('getStoredCollisionScene', 'scene', scene)
-            const localVarPath = `/cells/{cell}/store/collision/scenes/{scene}`
+            assertParamExists('getStoredCollisionSetup', 'cell', cell)
+            // verify required parameter 'setup' is not null or undefined
+            assertParamExists('getStoredCollisionSetup', 'setup', setup)
+            const localVarPath = `/cells/{cell}/store/collision/setups/{setup}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"scene"}}`, encodeURIComponent(String(scene)));
+                .replace(`{${"setup"}}`, encodeURIComponent(String(setup)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -10140,16 +10544,16 @@ export const StoreCollisionScenesApiAxiosParamCreator = function (configuration?
             };
         },
         /**
-         * Returns a list of stored scenes. 
-         * @summary List Scenes
+         * Returns a list of stored collision setups. 
+         * @summary List Collision Setups
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listStoredCollisionScenes: async (cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        listStoredCollisionSetups: async (cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('listStoredCollisionScenes', 'cell', cell)
-            const localVarPath = `/cells/{cell}/store/collision/scenes`
+            assertParamExists('listStoredCollisionSetups', 'cell', cell)
+            const localVarPath = `/cells/{cell}/store/collision/setups`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -10182,24 +10586,24 @@ export const StoreCollisionScenesApiAxiosParamCreator = function (configuration?
             };
         },
         /**
-         * Creates or replaces the stored collision scene.  The scene is assembled from components as defined in the request body.  <!-- theme: info --> > This endpoint allows indicating previously stored components. > Components used within the request will be copied into the new or updated scene.  An error is returned if an indicated component does not exist. 
-         * @summary Store Scene
+         * Stores collision setup.  If the collision setup does not exist, it will be created. If the collision setup exists, it will be updated. 
+         * @summary Store Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
-         * @param {CollisionSceneAssembly} collisionSceneAssembly 
+         * @param {string} setup Identifier of the collision setup
+         * @param {CollisionSetup} collisionSetup 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        storeCollisionScene: async (cell: string, scene: string, collisionSceneAssembly: CollisionSceneAssembly, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        storeCollisionSetup: async (cell: string, setup: string, collisionSetup: CollisionSetup, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('storeCollisionScene', 'cell', cell)
-            // verify required parameter 'scene' is not null or undefined
-            assertParamExists('storeCollisionScene', 'scene', scene)
-            // verify required parameter 'collisionSceneAssembly' is not null or undefined
-            assertParamExists('storeCollisionScene', 'collisionSceneAssembly', collisionSceneAssembly)
-            const localVarPath = `/cells/{cell}/store/collision/scenes/{scene}`
+            assertParamExists('storeCollisionSetup', 'cell', cell)
+            // verify required parameter 'setup' is not null or undefined
+            assertParamExists('storeCollisionSetup', 'setup', setup)
+            // verify required parameter 'collisionSetup' is not null or undefined
+            assertParamExists('storeCollisionSetup', 'collisionSetup', collisionSetup)
+            const localVarPath = `/cells/{cell}/store/collision/setups/{setup}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"scene"}}`, encodeURIComponent(String(scene)));
+                .replace(`{${"setup"}}`, encodeURIComponent(String(setup)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -10226,7 +10630,7 @@ export const StoreCollisionScenesApiAxiosParamCreator = function (configuration?
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-            localVarRequestOptions.data = serializeDataIfNeeded(collisionSceneAssembly, localVarRequestOptions, configuration)
+            localVarRequestOptions.data = serializeDataIfNeeded(collisionSetup, localVarRequestOptions, configuration)
 
             return {
                 url: toPathString(localVarUrlObj),
@@ -10237,182 +10641,182 @@ export const StoreCollisionScenesApiAxiosParamCreator = function (configuration?
 };
 
 /**
- * StoreCollisionScenesApi - functional programming interface
+ * StoreCollisionSetupsApi - functional programming interface
  * @export
  */
-export const StoreCollisionScenesApiFp = function(configuration?: Configuration) {
-    const localVarAxiosParamCreator = StoreCollisionScenesApiAxiosParamCreator(configuration)
+export const StoreCollisionSetupsApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = StoreCollisionSetupsApiAxiosParamCreator(configuration)
     return {
         /**
-         * Deletes the stored scene.  <!-- theme: danger --> > This will delete persistently stored data. 
-         * @summary Delete Scene
+         * Deletes the stored collision setup.  <!-- theme: danger --> > This will delete persistently stored data. 
+         * @summary Delete Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
+         * @param {string} setup Identifier of the collision setup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async deleteStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.deleteStoredCollisionScene(cell, scene, options);
+        async deleteStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.deleteStoredCollisionSetup(cell, setup, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['StoreCollisionScenesApi.deleteStoredCollisionScene']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['StoreCollisionSetupsApi.deleteStoredCollisionSetup']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Returns the stored scene. 
-         * @summary Get Scene
+         * Returns the stored collision setup. 
+         * @summary Get Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
+         * @param {string} setup Identifier of the collision setup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async getStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CollisionScene>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getStoredCollisionScene(cell, scene, options);
+        async getStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CollisionSetup>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getStoredCollisionSetup(cell, setup, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['StoreCollisionScenesApi.getStoredCollisionScene']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['StoreCollisionSetupsApi.getStoredCollisionSetup']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Returns a list of stored scenes. 
-         * @summary List Scenes
+         * Returns a list of stored collision setups. 
+         * @summary List Collision Setups
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async listStoredCollisionScenes(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{ [key: string]: CollisionScene; }>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listStoredCollisionScenes(cell, options);
+        async listStoredCollisionSetups(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{ [key: string]: CollisionSetup; }>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listStoredCollisionSetups(cell, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['StoreCollisionScenesApi.listStoredCollisionScenes']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['StoreCollisionSetupsApi.listStoredCollisionSetups']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Creates or replaces the stored collision scene.  The scene is assembled from components as defined in the request body.  <!-- theme: info --> > This endpoint allows indicating previously stored components. > Components used within the request will be copied into the new or updated scene.  An error is returned if an indicated component does not exist. 
-         * @summary Store Scene
+         * Stores collision setup.  If the collision setup does not exist, it will be created. If the collision setup exists, it will be updated. 
+         * @summary Store Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
-         * @param {CollisionSceneAssembly} collisionSceneAssembly 
+         * @param {string} setup Identifier of the collision setup
+         * @param {CollisionSetup} collisionSetup 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async storeCollisionScene(cell: string, scene: string, collisionSceneAssembly: CollisionSceneAssembly, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CollisionScene>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.storeCollisionScene(cell, scene, collisionSceneAssembly, options);
+        async storeCollisionSetup(cell: string, setup: string, collisionSetup: CollisionSetup, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CollisionSetup>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.storeCollisionSetup(cell, setup, collisionSetup, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['StoreCollisionScenesApi.storeCollisionScene']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['StoreCollisionSetupsApi.storeCollisionSetup']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     }
 };
 
 /**
- * StoreCollisionScenesApi - factory interface
+ * StoreCollisionSetupsApi - factory interface
  * @export
  */
-export const StoreCollisionScenesApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
-    const localVarFp = StoreCollisionScenesApiFp(configuration)
+export const StoreCollisionSetupsApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
+    const localVarFp = StoreCollisionSetupsApiFp(configuration)
     return {
         /**
-         * Deletes the stored scene.  <!-- theme: danger --> > This will delete persistently stored data. 
-         * @summary Delete Scene
+         * Deletes the stored collision setup.  <!-- theme: danger --> > This will delete persistently stored data. 
+         * @summary Delete Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
+         * @param {string} setup Identifier of the collision setup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        deleteStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
-            return localVarFp.deleteStoredCollisionScene(cell, scene, options).then((request) => request(axios, basePath));
+        deleteStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.deleteStoredCollisionSetup(cell, setup, options).then((request) => request(axios, basePath));
         },
         /**
-         * Returns the stored scene. 
-         * @summary Get Scene
+         * Returns the stored collision setup. 
+         * @summary Get Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
+         * @param {string} setup Identifier of the collision setup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig): AxiosPromise<CollisionScene> {
-            return localVarFp.getStoredCollisionScene(cell, scene, options).then((request) => request(axios, basePath));
+        getStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig): AxiosPromise<CollisionSetup> {
+            return localVarFp.getStoredCollisionSetup(cell, setup, options).then((request) => request(axios, basePath));
         },
         /**
-         * Returns a list of stored scenes. 
-         * @summary List Scenes
+         * Returns a list of stored collision setups. 
+         * @summary List Collision Setups
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listStoredCollisionScenes(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<{ [key: string]: CollisionScene; }> {
-            return localVarFp.listStoredCollisionScenes(cell, options).then((request) => request(axios, basePath));
+        listStoredCollisionSetups(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<{ [key: string]: CollisionSetup; }> {
+            return localVarFp.listStoredCollisionSetups(cell, options).then((request) => request(axios, basePath));
         },
         /**
-         * Creates or replaces the stored collision scene.  The scene is assembled from components as defined in the request body.  <!-- theme: info --> > This endpoint allows indicating previously stored components. > Components used within the request will be copied into the new or updated scene.  An error is returned if an indicated component does not exist. 
-         * @summary Store Scene
+         * Stores collision setup.  If the collision setup does not exist, it will be created. If the collision setup exists, it will be updated. 
+         * @summary Store Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
-         * @param {CollisionSceneAssembly} collisionSceneAssembly 
+         * @param {string} setup Identifier of the collision setup
+         * @param {CollisionSetup} collisionSetup 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        storeCollisionScene(cell: string, scene: string, collisionSceneAssembly: CollisionSceneAssembly, options?: RawAxiosRequestConfig): AxiosPromise<CollisionScene> {
-            return localVarFp.storeCollisionScene(cell, scene, collisionSceneAssembly, options).then((request) => request(axios, basePath));
+        storeCollisionSetup(cell: string, setup: string, collisionSetup: CollisionSetup, options?: RawAxiosRequestConfig): AxiosPromise<CollisionSetup> {
+            return localVarFp.storeCollisionSetup(cell, setup, collisionSetup, options).then((request) => request(axios, basePath));
         },
     };
 };
 
 /**
- * StoreCollisionScenesApi - object-oriented interface
+ * StoreCollisionSetupsApi - object-oriented interface
  * @export
- * @class StoreCollisionScenesApi
+ * @class StoreCollisionSetupsApi
  * @extends {BaseAPI}
  */
-export class StoreCollisionScenesApi extends BaseAPI {
+export class StoreCollisionSetupsApi extends BaseAPI {
     /**
-     * Deletes the stored scene.  <!-- theme: danger --> > This will delete persistently stored data. 
-     * @summary Delete Scene
+     * Deletes the stored collision setup.  <!-- theme: danger --> > This will delete persistently stored data. 
+     * @summary Delete Collision Setup
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {string} scene Unique identifier addressing a collision scene.
+     * @param {string} setup Identifier of the collision setup
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof StoreCollisionScenesApi
+     * @memberof StoreCollisionSetupsApi
      */
-    public deleteStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig) {
-        return StoreCollisionScenesApiFp(this.configuration).deleteStoredCollisionScene(cell, scene, options).then((request) => request(this.axios, this.basePath));
+    public deleteStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig) {
+        return StoreCollisionSetupsApiFp(this.configuration).deleteStoredCollisionSetup(cell, setup, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Returns the stored scene. 
-     * @summary Get Scene
+     * Returns the stored collision setup. 
+     * @summary Get Collision Setup
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {string} scene Unique identifier addressing a collision scene.
+     * @param {string} setup Identifier of the collision setup
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof StoreCollisionScenesApi
+     * @memberof StoreCollisionSetupsApi
      */
-    public getStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig) {
-        return StoreCollisionScenesApiFp(this.configuration).getStoredCollisionScene(cell, scene, options).then((request) => request(this.axios, this.basePath));
+    public getStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig) {
+        return StoreCollisionSetupsApiFp(this.configuration).getStoredCollisionSetup(cell, setup, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Returns a list of stored scenes. 
-     * @summary List Scenes
+     * Returns a list of stored collision setups. 
+     * @summary List Collision Setups
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof StoreCollisionScenesApi
+     * @memberof StoreCollisionSetupsApi
      */
-    public listStoredCollisionScenes(cell: string, options?: RawAxiosRequestConfig) {
-        return StoreCollisionScenesApiFp(this.configuration).listStoredCollisionScenes(cell, options).then((request) => request(this.axios, this.basePath));
+    public listStoredCollisionSetups(cell: string, options?: RawAxiosRequestConfig) {
+        return StoreCollisionSetupsApiFp(this.configuration).listStoredCollisionSetups(cell, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Creates or replaces the stored collision scene.  The scene is assembled from components as defined in the request body.  <!-- theme: info --> > This endpoint allows indicating previously stored components. > Components used within the request will be copied into the new or updated scene.  An error is returned if an indicated component does not exist. 
-     * @summary Store Scene
+     * Stores collision setup.  If the collision setup does not exist, it will be created. If the collision setup exists, it will be updated. 
+     * @summary Store Collision Setup
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {string} scene Unique identifier addressing a collision scene.
-     * @param {CollisionSceneAssembly} collisionSceneAssembly 
+     * @param {string} setup Identifier of the collision setup
+     * @param {CollisionSetup} collisionSetup 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof StoreCollisionScenesApi
+     * @memberof StoreCollisionSetupsApi
      */
-    public storeCollisionScene(cell: string, scene: string, collisionSceneAssembly: CollisionSceneAssembly, options?: RawAxiosRequestConfig) {
-        return StoreCollisionScenesApiFp(this.configuration).storeCollisionScene(cell, scene, collisionSceneAssembly, options).then((request) => request(this.axios, this.basePath));
+    public storeCollisionSetup(cell: string, setup: string, collisionSetup: CollisionSetup, options?: RawAxiosRequestConfig) {
+        return StoreCollisionSetupsApiFp(this.configuration).storeCollisionSetup(cell, setup, collisionSetup, options).then((request) => request(this.axios, this.basePath));
     }
 }
 
@@ -10975,16 +11379,14 @@ export class StoreObjectApi extends BaseAPI {
 export const SystemApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
         /**
-         * Retrieves a configuration backup based on provided resource identifiers. 
+         * Retrieves a configuration backup based on provided resource identifiers. If an empty array of resources is provided, a backup for all resources will be retrieved. 
          * @summary Retrieve Configuration Backup
-         * @param {Array<string>} resources List of resource identifiers to included in the backup and restore operations.
+         * @param {Array<string>} [resources] List of resource identifiers to include in the retrieval.
          * @param {{ [key: string]: string; }} [metadata] Additional metadata to add to the backup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        backupConfiguration: async (resources: Array<string>, metadata?: { [key: string]: string; }, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            // verify required parameter 'resources' is not null or undefined
-            assertParamExists('backupConfiguration', 'resources', resources)
+        backupConfiguration: async (resources?: Array<string>, metadata?: { [key: string]: string; }, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             const localVarPath = `/system/configuration`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -11372,14 +11774,14 @@ export const SystemApiFp = function(configuration?: Configuration) {
     const localVarAxiosParamCreator = SystemApiAxiosParamCreator(configuration)
     return {
         /**
-         * Retrieves a configuration backup based on provided resource identifiers. 
+         * Retrieves a configuration backup based on provided resource identifiers. If an empty array of resources is provided, a backup for all resources will be retrieved. 
          * @summary Retrieve Configuration Backup
-         * @param {Array<string>} resources List of resource identifiers to included in the backup and restore operations.
+         * @param {Array<string>} [resources] List of resource identifiers to include in the retrieval.
          * @param {{ [key: string]: string; }} [metadata] Additional metadata to add to the backup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async backupConfiguration(resources: Array<string>, metadata?: { [key: string]: string; }, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<File>> {
+        async backupConfiguration(resources?: Array<string>, metadata?: { [key: string]: string; }, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<File>> {
             const localVarAxiosArgs = await localVarAxiosParamCreator.backupConfiguration(resources, metadata, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['SystemApi.backupConfiguration']?.[localVarOperationServerIndex]?.url;
@@ -11497,14 +11899,14 @@ export const SystemApiFactory = function (configuration?: Configuration, basePat
     const localVarFp = SystemApiFp(configuration)
     return {
         /**
-         * Retrieves a configuration backup based on provided resource identifiers. 
+         * Retrieves a configuration backup based on provided resource identifiers. If an empty array of resources is provided, a backup for all resources will be retrieved. 
          * @summary Retrieve Configuration Backup
-         * @param {Array<string>} resources List of resource identifiers to included in the backup and restore operations.
+         * @param {Array<string>} [resources] List of resource identifiers to include in the retrieval.
          * @param {{ [key: string]: string; }} [metadata] Additional metadata to add to the backup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        backupConfiguration(resources: Array<string>, metadata?: { [key: string]: string; }, options?: RawAxiosRequestConfig): AxiosPromise<File> {
+        backupConfiguration(resources?: Array<string>, metadata?: { [key: string]: string; }, options?: RawAxiosRequestConfig): AxiosPromise<File> {
             return localVarFp.backupConfiguration(resources, metadata, options).then((request) => request(axios, basePath));
         },
         /**
@@ -11595,15 +11997,15 @@ export const SystemApiFactory = function (configuration?: Configuration, basePat
  */
 export class SystemApi extends BaseAPI {
     /**
-     * Retrieves a configuration backup based on provided resource identifiers. 
+     * Retrieves a configuration backup based on provided resource identifiers. If an empty array of resources is provided, a backup for all resources will be retrieved. 
      * @summary Retrieve Configuration Backup
-     * @param {Array<string>} resources List of resource identifiers to included in the backup and restore operations.
+     * @param {Array<string>} [resources] List of resource identifiers to include in the retrieval.
      * @param {{ [key: string]: string; }} [metadata] Additional metadata to add to the backup
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof SystemApi
      */
-    public backupConfiguration(resources: Array<string>, metadata?: { [key: string]: string; }, options?: RawAxiosRequestConfig) {
+    public backupConfiguration(resources?: Array<string>, metadata?: { [key: string]: string; }, options?: RawAxiosRequestConfig) {
         return SystemApiFp(this.configuration).backupConfiguration(resources, metadata, options).then((request) => request(this.axios, this.basePath));
     }
 
@@ -12324,7 +12726,53 @@ export class TrajectoryExecutionApi extends BaseAPI {
 export const TrajectoryPlanningApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
         /**
-         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion.
+         * Plans a collision-free trajectory for a single motion group using point-to-point (PTP) motions.  This endpoint is specifically designed for collision-free path planning algorithms that find a trajectory from a start joint position to a target position while avoiding obstacles.  Use the following workflow to execute a planned collision-free trajectory: 1. Plan a collision-free trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory planning fails due to collision or algorithm constraints, the response will contain error information about the failure. 
+         * @summary Plan Collision-Free Trajectory
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {PlanCollisionFreeRequest} [planCollisionFreeRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        planCollisionFree: async (cell: string, planCollisionFreeRequest?: PlanCollisionFreeRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('planCollisionFree', 'cell', cell)
+            const localVarPath = `/cells/{cell}/trajectory-planning/plan-collision-free`
+                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication BasicAuth required
+            // http basic authentication required
+            setBasicAuthToObject(localVarRequestOptions, configuration)
+
+            // authentication BearerAuth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration)
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(planCollisionFreeRequest, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion. 
          * @summary Plan Trajectory
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {PlanTrajectoryRequest} [planTrajectoryRequest] 
@@ -12380,7 +12828,21 @@ export const TrajectoryPlanningApiFp = function(configuration?: Configuration) {
     const localVarAxiosParamCreator = TrajectoryPlanningApiAxiosParamCreator(configuration)
     return {
         /**
-         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion.
+         * Plans a collision-free trajectory for a single motion group using point-to-point (PTP) motions.  This endpoint is specifically designed for collision-free path planning algorithms that find a trajectory from a start joint position to a target position while avoiding obstacles.  Use the following workflow to execute a planned collision-free trajectory: 1. Plan a collision-free trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory planning fails due to collision or algorithm constraints, the response will contain error information about the failure. 
+         * @summary Plan Collision-Free Trajectory
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {PlanCollisionFreeRequest} [planCollisionFreeRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async planCollisionFree(cell: string, planCollisionFreeRequest?: PlanCollisionFreeRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PlanCollisionFreeResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.planCollisionFree(cell, planCollisionFreeRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['TrajectoryPlanningApi.planCollisionFree']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion. 
          * @summary Plan Trajectory
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {PlanTrajectoryRequest} [planTrajectoryRequest] 
@@ -12404,7 +12866,18 @@ export const TrajectoryPlanningApiFactory = function (configuration?: Configurat
     const localVarFp = TrajectoryPlanningApiFp(configuration)
     return {
         /**
-         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion.
+         * Plans a collision-free trajectory for a single motion group using point-to-point (PTP) motions.  This endpoint is specifically designed for collision-free path planning algorithms that find a trajectory from a start joint position to a target position while avoiding obstacles.  Use the following workflow to execute a planned collision-free trajectory: 1. Plan a collision-free trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory planning fails due to collision or algorithm constraints, the response will contain error information about the failure. 
+         * @summary Plan Collision-Free Trajectory
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {PlanCollisionFreeRequest} [planCollisionFreeRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        planCollisionFree(cell: string, planCollisionFreeRequest?: PlanCollisionFreeRequest, options?: RawAxiosRequestConfig): AxiosPromise<PlanCollisionFreeResponse> {
+            return localVarFp.planCollisionFree(cell, planCollisionFreeRequest, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion. 
          * @summary Plan Trajectory
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {PlanTrajectoryRequest} [planTrajectoryRequest] 
@@ -12425,7 +12898,20 @@ export const TrajectoryPlanningApiFactory = function (configuration?: Configurat
  */
 export class TrajectoryPlanningApi extends BaseAPI {
     /**
-     * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion.
+     * Plans a collision-free trajectory for a single motion group using point-to-point (PTP) motions.  This endpoint is specifically designed for collision-free path planning algorithms that find a trajectory from a start joint position to a target position while avoiding obstacles.  Use the following workflow to execute a planned collision-free trajectory: 1. Plan a collision-free trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory planning fails due to collision or algorithm constraints, the response will contain error information about the failure. 
+     * @summary Plan Collision-Free Trajectory
+     * @param {string} cell Unique identifier addressing a cell in all API calls. 
+     * @param {PlanCollisionFreeRequest} [planCollisionFreeRequest] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof TrajectoryPlanningApi
+     */
+    public planCollisionFree(cell: string, planCollisionFreeRequest?: PlanCollisionFreeRequest, options?: RawAxiosRequestConfig) {
+        return TrajectoryPlanningApiFp(this.configuration).planCollisionFree(cell, planCollisionFreeRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion. 
      * @summary Plan Trajectory
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
      * @param {PlanTrajectoryRequest} [planTrajectoryRequest]