@wandelbots/nova-api 25.7.0-dev.26 → 25.7.0-dev.28

package/v2/api.ts

@@ -366,6 +366,182 @@ export const BoxBoxTypeEnum = {
 
 export type BoxBoxTypeEnum = typeof BoxBoxTypeEnum[keyof typeof BoxBoxTypeEnum];
 
+/**
+ * PROFINET BUS Inputs/Outputs Service configuration. 
+ * @export
+ * @interface BusIOProfinet
+ */
+export interface BusIOProfinet {
+    /**
+     * 
+     * @type {string}
+     * @memberof BusIOProfinet
+     */
+    'bus_type'?: BusIOProfinetBusTypeEnum;
+    /**
+     * Path to the configuration file.
+     * @type {string}
+     * @memberof BusIOProfinet
+     */
+    'config_file_content'?: string;
+    /**
+     * 
+     * @type {BusIOProfinetNetwork}
+     * @memberof BusIOProfinet
+     */
+    'network_config'?: BusIOProfinetNetwork;
+    /**
+     * MAC address for the PROFINET port, should be get from another NOVA API endpoind?
+     * @type {string}
+     * @memberof BusIOProfinet
+     */
+    'mac': string;
+    /**
+     * 
+     * @type {BusIOProfinetDefaultRoute}
+     * @memberof BusIOProfinet
+     */
+    'default_route': BusIOProfinetDefaultRoute;
+}
+
+export const BusIOProfinetBusTypeEnum = {
+    Profinet: 'profinet'
+} as const;
+
+export type BusIOProfinetBusTypeEnum = typeof BusIOProfinetBusTypeEnum[keyof typeof BusIOProfinetBusTypeEnum];
+
+/**
+ * Default route configuration for the PROFINET service. Will be removed before release by automatic default route configuration, if possible. 
+ * @export
+ * @interface BusIOProfinetDefaultRoute
+ */
+export interface BusIOProfinetDefaultRoute {
+    /**
+     * Gateway for the default route.
+     * @type {string}
+     * @memberof BusIOProfinetDefaultRoute
+     */
+    'gateway': string;
+    /**
+     * Interface for the default route.
+     * @type {string}
+     * @memberof BusIOProfinetDefaultRoute
+     */
+    'interface': string;
+}
+/**
+ * Network configuration for the PROFINET device
+ * @export
+ * @interface BusIOProfinetIpConfig
+ */
+export interface BusIOProfinetIpConfig {
+    /**
+     * IP address for the PROFINET device
+     * @type {string}
+     * @memberof BusIOProfinetIpConfig
+     */
+    'ip': string;
+    /**
+     * Network mask for the PROFINET device.
+     * @type {string}
+     * @memberof BusIOProfinetIpConfig
+     */
+    'netmask': string;
+    /**
+     * Gateway for the PROFINET device
+     * @type {string}
+     * @memberof BusIOProfinetIpConfig
+     */
+    'gateway': string;
+}
+/**
+ * 
+ * @export
+ * @interface BusIOProfinetNetwork
+ */
+export interface BusIOProfinetNetwork {
+    /**
+     * Name of the PROFINET device.
+     * @type {string}
+     * @memberof BusIOProfinetNetwork
+     */
+    'device_name'?: string;
+    /**
+     * 
+     * @type {BusIOProfinetIpConfig}
+     * @memberof BusIOProfinetNetwork
+     */
+    'ip_config'?: BusIOProfinetIpConfig;
+    /**
+     * Content of the PROFINET REMA XML file.
+     * @type {string}
+     * @memberof BusIOProfinetNetwork
+     */
+    'rema_xml_content'?: string;
+}
+/**
+ * Virtual PROFINET BUS Inputs/Outputs Service configuration. 
+ * @export
+ * @interface BusIOProfinetVirtual
+ */
+export interface BusIOProfinetVirtual {
+    /**
+     * 
+     * @type {string}
+     * @memberof BusIOProfinetVirtual
+     */
+    'bus_type'?: BusIOProfinetVirtualBusTypeEnum;
+}
+
+export const BusIOProfinetVirtualBusTypeEnum = {
+    VirtualProfinet: 'virtual_profinet'
+} as const;
+
+export type BusIOProfinetVirtualBusTypeEnum = typeof BusIOProfinetVirtualBusTypeEnum[keyof typeof BusIOProfinetVirtualBusTypeEnum];
+
+/**
+ * @type BusIOType
+ * @export
+ */
+export type BusIOType = { bus_type: 'profinet' } & BusIOProfinet | { bus_type: 'profinet_virtual' } & BusIOProfinetVirtual;
+
+/**
+ * 
+ * @export
+ * @interface BusIOsState
+ */
+export interface BusIOsState {
+    /**
+     * 
+     * @type {BusIOsStateEnum}
+     * @memberof BusIOsState
+     */
+    'state': BusIOsStateEnum;
+    /**
+     * A message providing additional information on the input/output, e.g. BUS service status, encountered errors. May be empty if no additional information is available. 
+     * @type {string}
+     * @memberof BusIOsState
+     */
+    'message'?: string;
+}
+
+
+/**
+ * Current state of the BUS input/output service. 
+ * @export
+ * @enum {string}
+ */
+
+export const BusIOsStateEnum = {
+    BusIosStateUnknown: 'BUS_IOS_STATE_UNKNOWN',
+    BusIosStateInitializing: 'BUS_IOS_STATE_INITIALIZING',
+    BusIosStateConnected: 'BUS_IOS_STATE_CONNECTED',
+    BusIosStateDisconnected: 'BUS_IOS_STATE_DISCONNECTED'
+} as const;
+
+export type BusIOsStateEnum = typeof BusIOsStateEnum[keyof typeof BusIOsStateEnum];
+
+
 /**
  * Defines a cylindrical shape with 2 semi-spheres on the top and bottom. Centred around origin, symmetric around z-axis. 
  * @export
@@ -514,13 +690,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 +727,7 @@ export interface CollisionContact {
      * @type {Array<number>}
      * @memberof CollisionContact
      */
-    'world'?: Array<number>;
+    'root'?: Array<number>;
 }
 /**
  * 
@@ -567,110 +743,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. 
@@ -1126,6 +1234,128 @@ export const Direction = {
 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 ErrorInvalidJointCount
+ */
+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 ErrorInvalidJointCount
+     */
+    'error_feedback_name': ErrorInvalidJointCountErrorFeedbackNameEnum;
+}
+
+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 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. 
  * @export
@@ -1403,49 +1633,128 @@ 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 GetTrajectoryResponse
+ * @interface ForwardKinematicsRequest
  */
-export interface GetTrajectoryResponse {
+export interface ForwardKinematicsRequest {
     /**
-     * Unique identifier of the motion group the trajectory is planned for.
+     * String identifiying the model of a motion group.
      * @type {string}
-     * @memberof GetTrajectoryResponse
+     * @memberof ForwardKinematicsRequest
      */
-    'motion_group': string;
+    'motion_group_model': string;
     /**
-     * The trajectory consisting of a list of joint positions and an equal number of corresponding timestamps. 
-     * @type {JointTrajectory}
-     * @memberof GetTrajectoryResponse
+     * List of joint positions [rad] for which TCP poses are computed. 
+     * @type {Array<Array<number>>}
+     * @memberof ForwardKinematicsRequest
      */
-    'trajectory': JointTrajectory;
+    'joint_positions': Array<Array<number>>;
     /**
-     * Unique identifier of the tool the trajectory is planned for.
-     * @type {string}
-     * @memberof GetTrajectoryResponse
+     * 
+     * @type {Pose}
+     * @memberof ForwardKinematicsRequest
      */
-    'tcp': string;
+    'tcp_offset'?: Pose;
+    /**
+     * Offset from the world frame to the motion group base.
+     * @type {Pose}
+     * @memberof ForwardKinematicsRequest
+     */
+    'mounting'?: Pose;
 }
 /**
  * 
  * @export
- * @interface HTTPValidationError
+ * @interface ForwardKinematicsResponse
  */
-export interface HTTPValidationError {
+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
+ * @interface GetTrajectoryResponse
+ */
+export interface GetTrajectoryResponse {
+    /**
+     * Unique identifier of the motion group the trajectory is planned for.
+     * @type {string}
+     * @memberof GetTrajectoryResponse
+     */
+    'motion_group': string;
+    /**
+     * The trajectory consisting of a list of joint positions and an equal number of corresponding timestamps. 
+     * @type {JointTrajectory}
+     * @memberof GetTrajectoryResponse
+     */
+    'trajectory': JointTrajectory;
+    /**
+     * Unique identifier of the tool the trajectory is planned for.
+     * @type {string}
+     * @memberof GetTrajectoryResponse
+     */
+    'tcp': string;
+}
+/**
+ * 
+ * @export
+ * @interface HTTPValidationError
+ */
+export interface HTTPValidationError {
     /**
      * 
      * @type {Array<ValidationError>}
@@ -1927,6 +2236,19 @@ export interface InvalidDofInvalidDof {
      */
     'joint_position'?: Array<number>;
 }
+/**
+ * 
+ * @export
+ * @interface InverseKinematics422Response
+ */
+export interface InverseKinematics422Response {
+    /**
+     * 
+     * @type {Array<InverseKinematicsValidationError>}
+     * @memberof InverseKinematics422Response
+     */
+    'detail'?: Array<InverseKinematicsValidationError>;
+}
 /**
  * 
  * @export
@@ -1964,11 +2286,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; };
 }
 /**
  * 
@@ -1983,6 +2305,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
@@ -2565,6 +2931,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
@@ -2745,6 +3137,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
@@ -3307,6 +3748,82 @@ export interface Payload {
      */
     'moment_of_inertia'?: Array<number>;
 }
+/**
+ * 
+ * @export
+ * @interface Plan422Response
+ */
+export interface Plan422Response {
+    /**
+     * 
+     * @type {Array<PlanValidationError>}
+     * @memberof Plan422Response
+     */
+    'detail'?: Array<PlanValidationError>;
+}
+/**
+ * Response when collision-free trajectory planning fails. Contains specific feedback about why the planning failed. 
+ * @export
+ * @interface PlanCollisionFreeFailedResponse
+ */
+export interface PlanCollisionFreeFailedResponse {
+    /**
+     * 
+     * @type {ErrorMaxIterationsExceeded}
+     * @memberof PlanCollisionFreeFailedResponse
+     */
+    'error_feedback': ErrorMaxIterationsExceeded;
+}
+/**
+ * 
+ * @export
+ * @interface PlanCollisionFreeRequest
+ */
+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 {Array<number>}
+     * @memberof PlanCollisionFreeRequest
+     */
+    'start_joint_position': Array<number>;
+    /**
+     * 
+     * @type {Array<number>}
+     * @memberof PlanCollisionFreeRequest
+     */
+    'target': Array<number>;
+    /**
+     * 
+     * @type {CollisionFreeAlgorithm}
+     * @memberof PlanCollisionFreeRequest
+     */
+    'algorithm': CollisionFreeAlgorithm;
+}
+/**
+ * Response from collision-free trajectory planning. Contains either a successful joint trajectory or failure information. 
+ * @export
+ * @interface PlanCollisionFreeResponse
+ */
+export interface PlanCollisionFreeResponse {
+    /**
+     * 
+     * @type {PlanCollisionFreeResponseResponse}
+     * @memberof PlanCollisionFreeResponse
+     */
+    'response': PlanCollisionFreeResponseResponse;
+}
+/**
+ * @type PlanCollisionFreeResponseResponse
+ * @export
+ */
+export type PlanCollisionFreeResponseResponse = JointTrajectory | PlanCollisionFreeFailedResponse;
+
 /**
  * 
  * @export
@@ -3346,10 +3863,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>}
@@ -3382,6 +3899,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
@@ -3474,36 +4035,295 @@ export interface Pose {
     'orientation'?: Array<number>;
 }
 /**
- * Defines an x/y-plane with finite size. Centred around the z-axis.
+ * 
  * @export
- * @interface Rectangle
+ * @interface ProfinetDescription
  */
-export interface Rectangle {
+export interface ProfinetDescription {
     /**
-     * 
+     * The vendor identifier of the PROFINET device, identifying the manufacturer. 
      * @type {string}
-     * @memberof Rectangle
+     * @memberof ProfinetDescription
      */
-    'shape_type': RectangleShapeTypeEnum;
+    'vendor_id': string;
     /**
-     * The dimension in x-direction in [mm].
-     * @type {number}
-     * @memberof Rectangle
+     * The device identifier of the PROFINET device, identifying the specific device within the vendor\'s range. 
+     * @type {string}
+     * @memberof ProfinetDescription
      */
-    'size_x': number;
+    'device_id': string;
     /**
-     * The dimension in y-direction in [mm].
-     * @type {number}
-     * @memberof Rectangle
+     * 
+     * @type {Array<ProfinetSlotDescription>}
+     * @memberof ProfinetDescription
      */
-    'size_y': number;
+    'slots'?: Array<ProfinetSlotDescription>;
+    /**
+     * Name of the PROFINET device
+     * @type {string}
+     * @memberof ProfinetDescription
+     */
+    'device_name'?: string;
+    /**
+     * IP address for the PROFINET device
+     * @type {string}
+     * @memberof ProfinetDescription
+     */
+    'ip'?: string;
 }
-
-export const RectangleShapeTypeEnum = {
-    Rectangle: 'rectangle'
-} as const;
-
-export type RectangleShapeTypeEnum = typeof RectangleShapeTypeEnum[keyof typeof RectangleShapeTypeEnum];
+/**
+ * 
+ * @export
+ * @interface ProfinetIO
+ */
+export interface ProfinetIO {
+    /**
+     * The name of the input/output value. This is a human-readable identifier for the value. It can be used to distinguish between different inputs/outputs in the system. 
+     * @type {string}
+     * @memberof ProfinetIO
+     */
+    'name': string;
+    /**
+     * 
+     * @type {ProfinetIOTypeEnum}
+     * @memberof ProfinetIO
+     */
+    'type': ProfinetIOTypeEnum;
+    /**
+     * The direction of the input/output value, indicating whether it is an input or output for the device. 
+     * @type {ProfinetIODirection}
+     * @memberof ProfinetIO
+     */
+    'direction': ProfinetIODirection;
+    /**
+     * The byte address of the input/output value in the PROFINET device. The byte address is used to locate the specific input/output within the device\'s memory or data structure. 
+     * @type {number}
+     * @memberof ProfinetIO
+     */
+    'byte_address': number;
+    /**
+     * The bit address of the input/output value within the byte or word address. The bit address is used to specify the exact bit within the byte or word that corresponds to the input/output value. 
+     * @type {number}
+     * @memberof ProfinetIO
+     */
+    'bit_address'?: number;
+    /**
+     * The unique identifier for the input/output value. This identifier is used to reference the specific input/output in the NOVA system. 
+     * @type {string}
+     * @memberof ProfinetIO
+     */
+    'io': string;
+}
+
+
+/**
+ * 
+ * @export
+ * @interface ProfinetIOData
+ */
+export interface ProfinetIOData {
+    /**
+     * The name of the input/output value. This is a human-readable identifier for the value. It can be used to distinguish between different inputs/outputs in the system. 
+     * @type {string}
+     * @memberof ProfinetIOData
+     */
+    'name': string;
+    /**
+     * 
+     * @type {ProfinetIOTypeEnum}
+     * @memberof ProfinetIOData
+     */
+    'type': ProfinetIOTypeEnum;
+    /**
+     * The direction of the input/output value, indicating whether it is an input or output for the device. 
+     * @type {ProfinetIODirection}
+     * @memberof ProfinetIOData
+     */
+    'direction': ProfinetIODirection;
+    /**
+     * The byte address of the input/output value in the PROFINET device. The byte address is used to locate the specific input/output within the device\'s memory or data structure. 
+     * @type {number}
+     * @memberof ProfinetIOData
+     */
+    'byte_address': number;
+    /**
+     * The bit address of the input/output value within the byte or word address. The bit address is used to specify the exact bit within the byte or word that corresponds to the input/output value. 
+     * @type {number}
+     * @memberof ProfinetIOData
+     */
+    'bit_address'?: number;
+}
+
+
+/**
+ * Identifies the input/output type.
+ * @export
+ * @enum {string}
+ */
+
+export const ProfinetIODirection = {
+    ProfinetIoDirectionInput: 'PROFINET_IO_DIRECTION_INPUT',
+    ProfinetIoDirectionOutput: 'PROFINET_IO_DIRECTION_OUTPUT',
+    ProfinetIoDirectionInout: 'PROFINET_IO_DIRECTION_INOUT'
+} as const;
+
+export type ProfinetIODirection = typeof ProfinetIODirection[keyof typeof ProfinetIODirection];
+
+
+/**
+ * Value type of the PROFINET input/output. 
+ * @export
+ * @enum {string}
+ */
+
+export const ProfinetIOTypeEnum = {
+    ProfinetIoTypeUnknown: 'PROFINET_IO_TYPE_UNKNOWN',
+    ProfinetIoTypeBool: 'PROFINET_IO_TYPE_BOOL',
+    ProfinetIoTypeUsint: 'PROFINET_IO_TYPE_USINT',
+    ProfinetIoTypeSint: 'PROFINET_IO_TYPE_SINT',
+    ProfinetIoTypeUint: 'PROFINET_IO_TYPE_UINT',
+    ProfinetIoTypeInt: 'PROFINET_IO_TYPE_INT',
+    ProfinetIoTypeUdint: 'PROFINET_IO_TYPE_UDINT',
+    ProfinetIoTypeDint: 'PROFINET_IO_TYPE_DINT',
+    ProfinetIoTypeReal: 'PROFINET_IO_TYPE_REAL',
+    ProfinetIoTypeLreal: 'PROFINET_IO_TYPE_LREAL'
+} as const;
+
+export type ProfinetIOTypeEnum = typeof ProfinetIOTypeEnum[keyof typeof ProfinetIOTypeEnum];
+
+
+/**
+ * 
+ * @export
+ * @interface ProfinetInputOutputConfig
+ */
+export interface ProfinetInputOutputConfig {
+    /**
+     * Content of the input output configuration file.
+     * @type {string}
+     * @memberof ProfinetInputOutputConfig
+     */
+    'config': string;
+    /**
+     * Offset in bytes for the input data.
+     * @type {number}
+     * @memberof ProfinetInputOutputConfig
+     */
+    'input_offset': number;
+    /**
+     * Offset in bytes for the output data.
+     * @type {number}
+     * @memberof ProfinetInputOutputConfig
+     */
+    'output_offset': number;
+}
+/**
+ * 
+ * @export
+ * @interface ProfinetSlotDescription
+ */
+export interface ProfinetSlotDescription {
+    /**
+     * The number of the PROFINET slot. 
+     * @type {number}
+     * @memberof ProfinetSlotDescription
+     */
+    'number': number;
+    /**
+     * The API number of the PROFINET input, used to identify the specific API for the input. 
+     * @type {number}
+     * @memberof ProfinetSlotDescription
+     */
+    'api': number;
+    /**
+     * An array of PROFINET subslots. 
+     * @type {Array<ProfinetSubSlotDescription>}
+     * @memberof ProfinetSlotDescription
+     */
+    'subslots': Array<ProfinetSubSlotDescription>;
+}
+/**
+ * 
+ * @export
+ * @interface ProfinetSubSlotDescription
+ */
+export interface ProfinetSubSlotDescription {
+    /**
+     * The identifier of the PROFINET subslot. 
+     * @type {number}
+     * @memberof ProfinetSubSlotDescription
+     */
+    'number': number;
+    /**
+     * The length in bytes of the PROFINET input. 
+     * @type {number}
+     * @memberof ProfinetSubSlotDescription
+     */
+    'input_length': number;
+    /**
+     * The length in bytes of the PROFINET output. 
+     * @type {number}
+     * @memberof ProfinetSubSlotDescription
+     */
+    'output_length': 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
+ * @interface Rectangle
+ */
+export interface Rectangle {
+    /**
+     * 
+     * @type {string}
+     * @memberof Rectangle
+     */
+    'shape_type': RectangleShapeTypeEnum;
+    /**
+     * The dimension in x-direction in [mm].
+     * @type {number}
+     * @memberof Rectangle
+     */
+    'size_x': number;
+    /**
+     * The dimension in y-direction in [mm].
+     * @type {number}
+     * @memberof Rectangle
+     */
+    'size_y': number;
+}
+
+export const RectangleShapeTypeEnum = {
+    Rectangle: 'rectangle'
+} as const;
+
+export type RectangleShapeTypeEnum = typeof RectangleShapeTypeEnum[keyof typeof RectangleShapeTypeEnum];
 
 /**
  * Convex hull around four spheres. Sphere center points in x/y-plane, offset by either combination \"+/- sizeX\" or \"+/- sizeY\".  Alternative description: Rectangle in x/y-plane with a 3D padding. 
@@ -3588,6 +4408,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}
@@ -3634,66 +4466,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];
@@ -3945,37 +4728,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
@@ -4562,6 +5314,12 @@ export interface ValidationError {
      * @memberof ValidationError
      */
     'type': string;
+    /**
+     * 
+     * @type {{ [key: string]: any; }}
+     * @memberof ValidationError
+     */
+    'input': { [key: string]: any; };
 }
 /**
  * @type ValidationErrorLocInner
@@ -5280,92 +6038,1222 @@ export const ApplicationApiFactory = function (configuration?: Configuration, ba
     };
 };
 
-/**
- * ApplicationApi - object-oriented interface
- * @export
- * @class ApplicationApi
- * @extends {BaseAPI}
- */
-export class ApplicationApi extends BaseAPI {
+/**
+ * ApplicationApi - object-oriented interface
+ * @export
+ * @class ApplicationApi
+ * @extends {BaseAPI}
+ */
+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 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 
+     * @param {number} [completionTimeout] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ApplicationApi
+     */
+    public addApp(cell: string, app: App, completionTimeout?: number, options?: RawAxiosRequestConfig) {
+        return ApplicationApiFp(this.configuration).addApp(cell, app, completionTimeout, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Delete all GUI applications from the cell.
+     * @summary Clear Applications
+     * @param {string} cell Unique identifier addressing a cell in all API calls. 
+     * @param {number} [completionTimeout] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ApplicationApi
+     */
+    public clearApps(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig) {
+        return ApplicationApiFp(this.configuration).clearApps(cell, completionTimeout, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Delete a GUI application from the cell.
+     * @summary Delete Application
+     * @param {string} cell Unique identifier addressing a cell in all API calls. 
+     * @param {string} app 
+     * @param {number} [completionTimeout] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ApplicationApi
+     */
+    public deleteApp(cell: string, app: string, completionTimeout?: number, options?: RawAxiosRequestConfig) {
+        return ApplicationApiFp(this.configuration).deleteApp(cell, app, completionTimeout, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Get the configuration for an active GUI application in the cell. To update the configuration of a GUI application in the cell, use this configuration with the \'Update Configuration\' endpoint. 
+     * @summary Configuration
+     * @param {string} cell Unique identifier addressing a cell in all API calls. 
+     * @param {string} app 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ApplicationApi
+     */
+    public getApp(cell: string, app: string, options?: RawAxiosRequestConfig) {
+        return ApplicationApiFp(this.configuration).getApp(cell, app, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * List all GUI applications that have been added to a cell. with the \'Add Application\' endpoint. If the cell does not contain GUI applications, the list is returned empty. 
+     * @summary List Applications
+     * @param {string} cell Unique identifier addressing a cell in all API calls. 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ApplicationApi
+     */
+    public listApps(cell: string, options?: RawAxiosRequestConfig) {
+        return ApplicationApiFp(this.configuration).listApps(cell, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Update the configuration of a GUI application in the cell.
+     * @summary Update Configuration
+     * @param {string} cell Unique identifier addressing a cell in all API calls. 
+     * @param {string} app 
+     * @param {App} app2 
+     * @param {number} [completionTimeout] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ApplicationApi
+     */
+    public updateApp(cell: string, app: string, app2: App, completionTimeout?: number, options?: RawAxiosRequestConfig) {
+        return ApplicationApiFp(this.configuration).updateApp(cell, app, app2, completionTimeout, options).then((request) => request(this.axios, this.basePath));
+    }
+}
+
+
+
+/**
+ * BUSInputsOutputsApi - axios parameter creator
+ * @export
+ */
+export const BUSInputsOutputsApiAxiosParamCreator = function (configuration?: Configuration) {
+    return {
+        /**
+         * Add a BUS Inputs/Outputs Service to the cell. 
+         * @summary Add Service
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {BusIOType} busIOType 
+         * @param {number} [completionTimeout] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        addBusIOService: async (cell: string, busIOType: BusIOType, completionTimeout?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('addBusIOService', 'cell', cell)
+            // verify required parameter 'busIOType' is not null or undefined
+            assertParamExists('addBusIOService', 'busIOType', busIOType)
+            const localVarPath = `/cells/{cell}/bus-ios`
+                .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)
+
+            if (completionTimeout !== undefined) {
+                localVarQueryParameter['completion_timeout'] = completionTimeout;
+            }
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(busIOType, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Adds an input/output to or updates an input/output on the PROFINET device. 
+         * @summary Add PROFINET Input/Output
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {string} io Unique identifier to address an Input/Output in the cell.
+         * @param {ProfinetIOData} profinetIOData 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        addProfinetIO: async (cell: string, io: string, profinetIOData: ProfinetIOData, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('addProfinetIO', 'cell', cell)
+            // verify required parameter 'io' is not null or undefined
+            assertParamExists('addProfinetIO', 'io', io)
+            // verify required parameter 'profinetIOData' is not null or undefined
+            assertParamExists('addProfinetIO', 'profinetIOData', profinetIOData)
+            const localVarPath = `/cells/{cell}/bus-ios/profinet/ios/{io}`
+                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
+                .replace(`{${"io"}}`, encodeURIComponent(String(io)));
+            // 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: 'PUT', ...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(profinetIOData, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Delete BUS Inputs/Outputs Service from the cell. 
+         * @summary Clear Service
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {number} [completionTimeout] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        clearBusIOService: async (cell: string, completionTimeout?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('clearBusIOService', 'cell', cell)
+            const localVarPath = `/cells/{cell}/bus-ios`
+                .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: 'DELETE', ...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)
+
+            if (completionTimeout !== undefined) {
+                localVarQueryParameter['completion_timeout'] = completionTimeout;
+            }
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Removes the input/output from the PROFINET device. 
+         * @summary Remove PROFINET Input/Ouptut
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {string} io Unique identifier to address an Input/Output in the cell.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        deleteProfinetIO: async (cell: string, io: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('deleteProfinetIO', 'cell', cell)
+            // verify required parameter 'io' is not null or undefined
+            assertParamExists('deleteProfinetIO', 'io', io)
+            const localVarPath = `/cells/{cell}/bus-ios/profinet/ios/{io}`
+                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
+                .replace(`{${"io"}}`, encodeURIComponent(String(io)));
+            // 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: 'DELETE', ...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};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Get deployed BUS Inputs/Outputs Service.
+         * @summary Get Service
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getBusIOService: async (cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('getBusIOService', 'cell', cell)
+            const localVarPath = `/cells/{cell}/bus-ios`
+                .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: '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};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Get the current state of the BUS Inputs/Outputs service. 
+         * @summary State
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getBusIOState: async (cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('getBusIOState', 'cell', cell)
+            const localVarPath = `/cells/{cell}/bus-ios/state`
+                .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: '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};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Retrieves the current values of inputs/outputs.  The identifiers of the inputs/outputs must be provided in the request. Request all available input/output identifiers via [listBusIODescriptions](listBusIODescriptions). 
+         * @summary Get Input/Output Values
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {Array<string>} [ios] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getBusIOValues: async (cell: string, ios?: Array<string>, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('getBusIOValues', 'cell', cell)
+            const localVarPath = `/cells/{cell}/bus-ios/ios/values`
+                .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: '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)
+
+            if (ios) {
+                localVarQueryParameter['ios'] = ios;
+            }
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Get description of PROFINET 
+         * @summary Get PROFINET Description
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getProfinetDescription: async (cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('getProfinetDescription', 'cell', cell)
+            const localVarPath = `/cells/{cell}/bus-ios/profinet/description`
+                .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: '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};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Get input/output configuration of the PROFINET device as file. 
+         * @summary PROFINET Inputs/Outputs to File
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {number} [inputOffset] 
+         * @param {number} [outputOffset] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getProfinetIOsFromFile: async (cell: string, inputOffset?: number, outputOffset?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('getProfinetIOsFromFile', 'cell', cell)
+            const localVarPath = `/cells/{cell}/bus-ios/profinet/iofile`
+                .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: '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)
+
+            if (inputOffset !== undefined) {
+                localVarQueryParameter['input_offset'] = inputOffset;
+            }
+
+            if (outputOffset !== undefined) {
+                localVarQueryParameter['output_offset'] = outputOffset;
+            }
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * List all BUS Input/Output descriptions. 
+         * @summary List Descriptions
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listBusIODescriptions: async (cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('listBusIODescriptions', 'cell', cell)
+            const localVarPath = `/cells/{cell}/bus-ios/ios/description`
+                .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: '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};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * List all PROFINET input and outputs. 
+         * @summary List PROFINET Input/Output Configuration
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listProfinetIOs: async (cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('listProfinetIOs', 'cell', cell)
+            const localVarPath = `/cells/{cell}/bus-ios/profinet/ios`
+                .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: '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};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Set values of outputs. In case of virtual Bus Input/Outputs, also inputs can be set.  All available output identifiers can be requested via [listBusIODescriptions](listBusIODescriptions).  The call will return once the values have been set and accepted by the service. 
+         * @summary Set Output Values
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {Array<IOValue>} iOValue 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        setBusIOValues: async (cell: string, iOValue: Array<IOValue>, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('setBusIOValues', 'cell', cell)
+            // verify required parameter 'iOValue' is not null or undefined
+            assertParamExists('setBusIOValues', 'iOValue', iOValue)
+            const localVarPath = `/cells/{cell}/bus-ios/ios/values`
+                .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: 'PUT', ...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(iOValue, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Sets inputs/outputs on the PROFINET device from file. 
+         * @summary Set PROFINET Inputs/Outputs from File
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {ProfinetInputOutputConfig} profinetInputOutputConfig 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        setProfinetIOsFromFile: async (cell: string, profinetInputOutputConfig: ProfinetInputOutputConfig, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('setProfinetIOsFromFile', 'cell', cell)
+            // verify required parameter 'profinetInputOutputConfig' is not null or undefined
+            assertParamExists('setProfinetIOsFromFile', 'profinetInputOutputConfig', profinetInputOutputConfig)
+            const localVarPath = `/cells/{cell}/bus-ios/profinet/iofile`
+                .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: 'PUT', ...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(profinetInputOutputConfig, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    }
+};
+
+/**
+ * BUSInputsOutputsApi - functional programming interface
+ * @export
+ */
+export const BUSInputsOutputsApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = BUSInputsOutputsApiAxiosParamCreator(configuration)
+    return {
+        /**
+         * Add a BUS Inputs/Outputs Service to the cell. 
+         * @summary Add Service
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {BusIOType} busIOType 
+         * @param {number} [completionTimeout] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async addBusIOService(cell: string, busIOType: BusIOType, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.addBusIOService(cell, busIOType, completionTimeout, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['BUSInputsOutputsApi.addBusIOService']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Adds an input/output to or updates an input/output on the PROFINET device. 
+         * @summary Add PROFINET Input/Output
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {string} io Unique identifier to address an Input/Output in the cell.
+         * @param {ProfinetIOData} profinetIOData 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async addProfinetIO(cell: string, io: string, profinetIOData: ProfinetIOData, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.addProfinetIO(cell, io, profinetIOData, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['BUSInputsOutputsApi.addProfinetIO']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Delete BUS Inputs/Outputs Service from the cell. 
+         * @summary Clear Service
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {number} [completionTimeout] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async clearBusIOService(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.clearBusIOService(cell, completionTimeout, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['BUSInputsOutputsApi.clearBusIOService']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Removes the input/output from the PROFINET device. 
+         * @summary Remove PROFINET Input/Ouptut
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {string} io Unique identifier to address an Input/Output in the cell.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async deleteProfinetIO(cell: string, io: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.deleteProfinetIO(cell, io, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['BUSInputsOutputsApi.deleteProfinetIO']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Get deployed BUS Inputs/Outputs Service.
+         * @summary Get Service
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getBusIOService(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<BusIOType>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getBusIOService(cell, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['BUSInputsOutputsApi.getBusIOService']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Get the current state of the BUS Inputs/Outputs service. 
+         * @summary State
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getBusIOState(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<BusIOsState>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getBusIOState(cell, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['BUSInputsOutputsApi.getBusIOState']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Retrieves the current values of inputs/outputs.  The identifiers of the inputs/outputs must be provided in the request. Request all available input/output identifiers via [listBusIODescriptions](listBusIODescriptions). 
+         * @summary Get Input/Output Values
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {Array<string>} [ios] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getBusIOValues(cell: string, ios?: Array<string>, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<IOValue>>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getBusIOValues(cell, ios, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['BUSInputsOutputsApi.getBusIOValues']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Get description of PROFINET 
+         * @summary Get PROFINET Description
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getProfinetDescription(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProfinetDescription>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getProfinetDescription(cell, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['BUSInputsOutputsApi.getProfinetDescription']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Get input/output configuration of the PROFINET device as file. 
+         * @summary PROFINET Inputs/Outputs to File
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {number} [inputOffset] 
+         * @param {number} [outputOffset] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getProfinetIOsFromFile(cell: string, inputOffset?: number, outputOffset?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<string>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getProfinetIOsFromFile(cell, inputOffset, outputOffset, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['BUSInputsOutputsApi.getProfinetIOsFromFile']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * List all BUS Input/Output descriptions. 
+         * @summary List Descriptions
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async listBusIODescriptions(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<IODescription>>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listBusIODescriptions(cell, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['BUSInputsOutputsApi.listBusIODescriptions']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * List all PROFINET input and outputs. 
+         * @summary List PROFINET Input/Output Configuration
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async listProfinetIOs(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<ProfinetIO>>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listProfinetIOs(cell, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['BUSInputsOutputsApi.listProfinetIOs']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Set values of outputs. In case of virtual Bus Input/Outputs, also inputs can be set.  All available output identifiers can be requested via [listBusIODescriptions](listBusIODescriptions).  The call will return once the values have been set and accepted by the service. 
+         * @summary Set Output Values
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {Array<IOValue>} iOValue 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async setBusIOValues(cell: string, iOValue: Array<IOValue>, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.setBusIOValues(cell, iOValue, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['BUSInputsOutputsApi.setBusIOValues']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Sets inputs/outputs on the PROFINET device from file. 
+         * @summary Set PROFINET Inputs/Outputs from File
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {ProfinetInputOutputConfig} profinetInputOutputConfig 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async setProfinetIOsFromFile(cell: string, profinetInputOutputConfig: ProfinetInputOutputConfig, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.setProfinetIOsFromFile(cell, profinetInputOutputConfig, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['BUSInputsOutputsApi.setProfinetIOsFromFile']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    }
+};
+
+/**
+ * BUSInputsOutputsApi - factory interface
+ * @export
+ */
+export const BUSInputsOutputsApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
+    const localVarFp = BUSInputsOutputsApiFp(configuration)
+    return {
+        /**
+         * Add a BUS Inputs/Outputs Service to the cell. 
+         * @summary Add Service
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {BusIOType} busIOType 
+         * @param {number} [completionTimeout] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        addBusIOService(cell: string, busIOType: BusIOType, completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.addBusIOService(cell, busIOType, completionTimeout, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Adds an input/output to or updates an input/output on the PROFINET device. 
+         * @summary Add PROFINET Input/Output
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {string} io Unique identifier to address an Input/Output in the cell.
+         * @param {ProfinetIOData} profinetIOData 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        addProfinetIO(cell: string, io: string, profinetIOData: ProfinetIOData, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.addProfinetIO(cell, io, profinetIOData, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Delete BUS Inputs/Outputs Service from the cell. 
+         * @summary Clear Service
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {number} [completionTimeout] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        clearBusIOService(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.clearBusIOService(cell, completionTimeout, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Removes the input/output from the PROFINET device. 
+         * @summary Remove PROFINET Input/Ouptut
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {string} io Unique identifier to address an Input/Output in the cell.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        deleteProfinetIO(cell: string, io: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.deleteProfinetIO(cell, io, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Get deployed BUS Inputs/Outputs Service.
+         * @summary Get Service
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getBusIOService(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<BusIOType> {
+            return localVarFp.getBusIOService(cell, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Get the current state of the BUS Inputs/Outputs service. 
+         * @summary State
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getBusIOState(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<BusIOsState> {
+            return localVarFp.getBusIOState(cell, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Retrieves the current values of inputs/outputs.  The identifiers of the inputs/outputs must be provided in the request. Request all available input/output identifiers via [listBusIODescriptions](listBusIODescriptions). 
+         * @summary Get Input/Output Values
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {Array<string>} [ios] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getBusIOValues(cell: string, ios?: Array<string>, options?: RawAxiosRequestConfig): AxiosPromise<Array<IOValue>> {
+            return localVarFp.getBusIOValues(cell, ios, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Get description of PROFINET 
+         * @summary Get PROFINET Description
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getProfinetDescription(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<ProfinetDescription> {
+            return localVarFp.getProfinetDescription(cell, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Get input/output configuration of the PROFINET device as file. 
+         * @summary PROFINET Inputs/Outputs to File
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {number} [inputOffset] 
+         * @param {number} [outputOffset] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getProfinetIOsFromFile(cell: string, inputOffset?: number, outputOffset?: number, options?: RawAxiosRequestConfig): AxiosPromise<string> {
+            return localVarFp.getProfinetIOsFromFile(cell, inputOffset, outputOffset, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * List all BUS Input/Output descriptions. 
+         * @summary List Descriptions
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listBusIODescriptions(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<IODescription>> {
+            return localVarFp.listBusIODescriptions(cell, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * List all PROFINET input and outputs. 
+         * @summary List PROFINET Input/Output Configuration
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listProfinetIOs(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<ProfinetIO>> {
+            return localVarFp.listProfinetIOs(cell, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Set values of outputs. In case of virtual Bus Input/Outputs, also inputs can be set.  All available output identifiers can be requested via [listBusIODescriptions](listBusIODescriptions).  The call will return once the values have been set and accepted by the service. 
+         * @summary Set Output Values
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {Array<IOValue>} iOValue 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        setBusIOValues(cell: string, iOValue: Array<IOValue>, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.setBusIOValues(cell, iOValue, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Sets inputs/outputs on the PROFINET device from file. 
+         * @summary Set PROFINET Inputs/Outputs from File
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {ProfinetInputOutputConfig} profinetInputOutputConfig 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        setProfinetIOsFromFile(cell: string, profinetInputOutputConfig: ProfinetInputOutputConfig, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.setProfinetIOsFromFile(cell, profinetInputOutputConfig, options).then((request) => request(axios, basePath));
+        },
+    };
+};
+
+/**
+ * BUSInputsOutputsApi - object-oriented interface
+ * @export
+ * @class BUSInputsOutputsApi
+ * @extends {BaseAPI}
+ */
+export class BUSInputsOutputsApi extends BaseAPI {
+    /**
+     * Add a BUS Inputs/Outputs Service to the cell. 
+     * @summary Add Service
+     * @param {string} cell Unique identifier addressing a cell in all API calls. 
+     * @param {BusIOType} busIOType 
+     * @param {number} [completionTimeout] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof BUSInputsOutputsApi
+     */
+    public addBusIOService(cell: string, busIOType: BusIOType, completionTimeout?: number, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).addBusIOService(cell, busIOType, completionTimeout, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Adds an input/output to or updates an input/output on the PROFINET device. 
+     * @summary Add PROFINET Input/Output
+     * @param {string} cell Unique identifier addressing a cell in all API calls. 
+     * @param {string} io Unique identifier to address an Input/Output in the cell.
+     * @param {ProfinetIOData} profinetIOData 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof BUSInputsOutputsApi
+     */
+    public addProfinetIO(cell: string, io: string, profinetIOData: ProfinetIOData, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).addProfinetIO(cell, io, profinetIOData, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Delete BUS Inputs/Outputs Service from the cell. 
+     * @summary Clear Service
+     * @param {string} cell Unique identifier addressing a cell in all API calls. 
+     * @param {number} [completionTimeout] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof BUSInputsOutputsApi
+     */
+    public clearBusIOService(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).clearBusIOService(cell, completionTimeout, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Removes the input/output from the PROFINET device. 
+     * @summary Remove PROFINET Input/Ouptut
+     * @param {string} cell Unique identifier addressing a cell in all API calls. 
+     * @param {string} io Unique identifier to address an Input/Output in the cell.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof BUSInputsOutputsApi
+     */
+    public deleteProfinetIO(cell: string, io: string, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).deleteProfinetIO(cell, io, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Get deployed BUS Inputs/Outputs Service.
+     * @summary Get Service
+     * @param {string} cell Unique identifier addressing a cell in all API calls. 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof BUSInputsOutputsApi
+     */
+    public getBusIOService(cell: string, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).getBusIOService(cell, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
-     * 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
+     * Get the current state of the BUS Inputs/Outputs service. 
+     * @summary State
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {App} app 
-     * @param {number} [completionTimeout] 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof ApplicationApi
+     * @memberof BUSInputsOutputsApi
      */
-    public addApp(cell: string, app: App, completionTimeout?: number, options?: RawAxiosRequestConfig) {
-        return ApplicationApiFp(this.configuration).addApp(cell, app, completionTimeout, options).then((request) => request(this.axios, this.basePath));
+    public getBusIOState(cell: string, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).getBusIOState(cell, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Delete all GUI applications from the cell.
-     * @summary Clear Applications
+     * Retrieves the current values of inputs/outputs.  The identifiers of the inputs/outputs must be provided in the request. Request all available input/output identifiers via [listBusIODescriptions](listBusIODescriptions). 
+     * @summary Get Input/Output Values
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {number} [completionTimeout] 
+     * @param {Array<string>} [ios] 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof ApplicationApi
+     * @memberof BUSInputsOutputsApi
      */
-    public clearApps(cell: string, completionTimeout?: number, options?: RawAxiosRequestConfig) {
-        return ApplicationApiFp(this.configuration).clearApps(cell, completionTimeout, options).then((request) => request(this.axios, this.basePath));
+    public getBusIOValues(cell: string, ios?: Array<string>, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).getBusIOValues(cell, ios, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Delete a GUI application from the cell.
-     * @summary Delete Application
+     * Get description of PROFINET 
+     * @summary Get PROFINET Description
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {string} app 
-     * @param {number} [completionTimeout] 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof ApplicationApi
+     * @memberof BUSInputsOutputsApi
      */
-    public deleteApp(cell: string, app: string, completionTimeout?: number, options?: RawAxiosRequestConfig) {
-        return ApplicationApiFp(this.configuration).deleteApp(cell, app, completionTimeout, options).then((request) => request(this.axios, this.basePath));
+    public getProfinetDescription(cell: string, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).getProfinetDescription(cell, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Get the configuration for an active GUI application in the cell. To update the configuration of a GUI application in the cell, use this configuration with the \'Update Configuration\' endpoint. 
-     * @summary Configuration
+     * Get input/output configuration of the PROFINET device as file. 
+     * @summary PROFINET Inputs/Outputs to File
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {string} app 
+     * @param {number} [inputOffset] 
+     * @param {number} [outputOffset] 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof ApplicationApi
+     * @memberof BUSInputsOutputsApi
      */
-    public getApp(cell: string, app: string, options?: RawAxiosRequestConfig) {
-        return ApplicationApiFp(this.configuration).getApp(cell, app, options).then((request) => request(this.axios, this.basePath));
+    public getProfinetIOsFromFile(cell: string, inputOffset?: number, outputOffset?: number, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).getProfinetIOsFromFile(cell, inputOffset, outputOffset, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * List all GUI applications that have been added to a cell. with the \'Add Application\' endpoint. If the cell does not contain GUI applications, the list is returned empty. 
-     * @summary List Applications
+     * List all BUS Input/Output descriptions. 
+     * @summary List Descriptions
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof ApplicationApi
+     * @memberof BUSInputsOutputsApi
      */
-    public listApps(cell: string, options?: RawAxiosRequestConfig) {
-        return ApplicationApiFp(this.configuration).listApps(cell, options).then((request) => request(this.axios, this.basePath));
+    public listBusIODescriptions(cell: string, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).listBusIODescriptions(cell, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Update the configuration of a GUI application in the cell.
-     * @summary Update Configuration
+     * List all PROFINET input and outputs. 
+     * @summary List PROFINET Input/Output Configuration
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {string} app 
-     * @param {App} app2 
-     * @param {number} [completionTimeout] 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof ApplicationApi
+     * @memberof BUSInputsOutputsApi
      */
-    public updateApp(cell: string, app: string, app2: App, completionTimeout?: number, options?: RawAxiosRequestConfig) {
-        return ApplicationApiFp(this.configuration).updateApp(cell, app, app2, completionTimeout, options).then((request) => request(this.axios, this.basePath));
+    public listProfinetIOs(cell: string, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).listProfinetIOs(cell, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Set values of outputs. In case of virtual Bus Input/Outputs, also inputs can be set.  All available output identifiers can be requested via [listBusIODescriptions](listBusIODescriptions).  The call will return once the values have been set and accepted by the service. 
+     * @summary Set Output Values
+     * @param {string} cell Unique identifier addressing a cell in all API calls. 
+     * @param {Array<IOValue>} iOValue 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof BUSInputsOutputsApi
+     */
+    public setBusIOValues(cell: string, iOValue: Array<IOValue>, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).setBusIOValues(cell, iOValue, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Sets inputs/outputs on the PROFINET device from file. 
+     * @summary Set PROFINET Inputs/Outputs from File
+     * @param {string} cell Unique identifier addressing a cell in all API calls. 
+     * @param {ProfinetInputOutputConfig} profinetInputOutputConfig 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof BUSInputsOutputsApi
+     */
+    public setProfinetIOsFromFile(cell: string, profinetInputOutputConfig: ProfinetInputOutputConfig, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).setProfinetIOsFromFile(cell, profinetInputOutputConfig, options).then((request) => request(this.axios, this.basePath));
     }
 }
 
@@ -6282,52 +8170,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};
@@ -6627,15 +8469,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
@@ -6666,6 +8509,10 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
                 localVarQueryParameter['response_rate'] = responseRate;
             }
 
+            if (addControllerTimeout !== undefined) {
+                localVarQueryParameter['add_controller_timeout'] = addControllerTimeout;
+            }
+
 
     
             setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -6832,20 +8679,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
@@ -6933,16 +8766,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);
@@ -7043,17 +8877,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
@@ -7123,16 +8946,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. 
@@ -7239,19 +9063,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
@@ -7333,17 +9144,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));
     }
 
     /**
@@ -8027,6 +9839,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
@@ -8083,6 +9941,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
@@ -8107,6 +9979,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
@@ -8128,6 +10011,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
@@ -10062,27 +11958,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;
@@ -10114,21 +12010,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;
@@ -10160,16 +12056,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);
@@ -10202,24 +12098,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;
@@ -10246,7 +12142,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),
@@ -10257,182 +12153,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));
     }
 }
 
@@ -12344,7 +14240,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] 
@@ -12400,7 +14342,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] 
@@ -12424,7 +14380,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] 
@@ -12445,7 +14412,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]