@wandelbots/nova-api 25.7.0-dev.8 → 25.7.0-rc.1

package/v2/api.ts

@@ -210,6 +210,12 @@ export interface App {
      * @memberof App
      */
     'storage'?: ContainerStorage;
+    /**
+     * 
+     * @type {ContainerResources}
+     * @memberof App
+     */
+    'resources'?: ContainerResources;
     /**
      * Defines the URL path suffix used to check the application\'s health status. The complete health check URL is constructed as `/$cell/$name/$health_path`. When the application is working as expected, the endpoint returns an HTTP 200 status code.  If not specified, the system will default to using the application icon path suffix (the value of `app_icon`) as the health check endpoint, resulting in `/$cell/$name/$app_icon`.  If the health check fails (no response or non-200 status code), the system will automatically restart the application container to restore service. 
      * @type {string}
@@ -366,6 +372,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 +696,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 +733,7 @@ export interface CollisionContact {
      * @type {Array<number>}
      * @memberof CollisionContact
      */
-    'world'?: Array<number>;
+    'root'?: Array<number>;
 }
 /**
  * 
@@ -567,110 +749,42 @@ export interface CollisionError {
     'collision'?: FeedbackCollision;
 }
 /**
- * 
+ * @type CollisionFreeAlgorithm
+ * Configuration for collision-free path planning algorithms. Different algorithms may have different parameters and behavior. 
  * @export
- * @interface CollisionMotionGroup
  */
-export interface CollisionMotionGroup {
-    /**
-     * A link chain is a kinematic chain of links that is connected via joints. A motion group can be used to control the motion of the joints in a link chain.  A link is a group of colliders that is attached to the link reference frame.  The reference frame of a link is obtained after applying all sets of Denavit-Hartenberg-parameters from base to (including) the link index.  This means that the reference frame of the link is on the rotation axis of the next joint in the kinematic chain. Example: For a motion group with 2 joints, the collider reference frame (CRF) for link 1 is on the rotation axis of joint 2. The chain looks like: - Origin >> Mounting >> Base >> (CRF Base) Joint 0 >> Link 0 >> (CRF Link 0) Joint 1 >> Link 1 >> (CRF Link 1) Flange (CRF Tool) >> TCP  Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. 
-     * @type {Array<{ [key: string]: Collider; }>}
-     * @memberof CollisionMotionGroup
-     */
-    'link_chain'?: Array<{ [key: string]: Collider; }>;
-    /**
-     * Defines the shape of a tool.  A tool is a dictionary of colliders.  All colliders that make up a tool are attached to the flange frame of the motion group. 
-     * @type {{ [key: string]: Collider; }}
-     * @memberof CollisionMotionGroup
-     */
-    'tool'?: { [key: string]: Collider; };
-}
+export type CollisionFreeAlgorithm = MidpointInsertionAlgorithm | RRTConnectAlgorithm;
+
 /**
  * 
  * @export
- * @interface CollisionMotionGroupAssembly
+ * @interface CollisionSetup
  */
-export interface CollisionMotionGroupAssembly {
-    /**
-     * References a stored link chain. 
-     * @type {string}
-     * @memberof CollisionMotionGroupAssembly
-     */
-    'stored_link_chain'?: string;
+export interface CollisionSetup {
     /**
-     * References a stored tool. 
-     * @type {string}
-     * @memberof CollisionMotionGroupAssembly
+     * A collection of identifiable colliders.
+     * @type {{ [key: string]: Collider; }}
+     * @memberof CollisionSetup
      */
-    'stored_tool'?: string;
+    'colliders'?: { [key: string]: Collider; };
     /**
      * A link chain is a kinematic chain of links that is connected via joints. A motion group can be used to control the motion of the joints in a link chain.  A link is a group of colliders that is attached to the link reference frame.  The reference frame of a link is obtained after applying all sets of Denavit-Hartenberg-parameters from base to (including) the link index.  This means that the reference frame of the link is on the rotation axis of the next joint in the kinematic chain. Example: For a motion group with 2 joints, the collider reference frame (CRF) for link 1 is on the rotation axis of joint 2. The chain looks like: - Origin >> Mounting >> Base >> (CRF Base) Joint 0 >> Link 0 >> (CRF Link 0) Joint 1 >> Link 1 >> (CRF Link 1) Flange (CRF Tool) >> TCP  Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. 
      * @type {Array<{ [key: string]: Collider; }>}
-     * @memberof CollisionMotionGroupAssembly
+     * @memberof CollisionSetup
      */
     'link_chain'?: Array<{ [key: string]: Collider; }>;
     /**
      * Defines the shape of a tool.  A tool is a dictionary of colliders.  All colliders that make up a tool are attached to the flange frame of the motion group. 
      * @type {{ [key: string]: Collider; }}
-     * @memberof CollisionMotionGroupAssembly
+     * @memberof CollisionSetup
      */
     'tool'?: { [key: string]: Collider; };
-}
-/**
- * Defines the collision scene.  There are two types of objects in the scene: - `colliders`: Each collider is attached directly to the origin of the scene: Origin >> Collider - `motion-groups`: Each motion group is assigned a kinematic chain of links with a special collider, called tool, attached to the last element.   The motion group is attached to the origin of the scene via its mounting: Origin >> Mounting >> Motion Group Base >> […] 
- * @export
- * @interface CollisionScene
- */
-export interface CollisionScene {
-    /**
-     * A collection of identifiable colliders.
-     * @type {{ [key: string]: Collider; }}
-     * @memberof CollisionScene
-     */
-    'colliders'?: { [key: string]: Collider; };
-    /**
-     * Maps a Wandelbots NOVA motion group to its configuration in the collision scene. Key must be a motion group identifier.  Values are collision motion group objects.  A collision motion group defines a motion group in the collision scene.  The motion group is attached to the origin of the scene. To relocate the motion group, configure its mounting offset on the physical controller. This ensures that the definition of motion commands and collision scenes use the same coordinate system. The kinematic chain looks like this: - Origin >> Mounting >> Base >> Joint 0 >> Link 0 >> Joint 1 >> […] >> TCP  A `tool` is treated like another link attached to the end (flange) of the kinematic chain. All tool colliders are described in the flange frame. 
-     * @type {{ [key: string]: CollisionMotionGroup; }}
-     * @memberof CollisionScene
-     */
-    'motion_groups'?: { [key: string]: CollisionMotionGroup; };
-}
-/**
- * Defines the collision scene assembly. Merges all referenced and new scene components into a single scene.  Previously added components with identical identifiers are overwritten within the same group.  There is one group for each of the following components: - Colliders attached to the origin of the scene, - Tool per motion group, and - For each link per motion group.  The scene is assembled by adding components in the following order. 1. stored_scenes 2. scene 3. stored_colliders 4. colliders 5. stored_link_chains and stored_tools (per motion group) 6. link_chains and tools (per motion group) 
- * @export
- * @interface CollisionSceneAssembly
- */
-export interface CollisionSceneAssembly {
-    /**
-     * Add stored scenes to the scene via their identifiers. The scenes are merged based on their order in the array. The scene at index zero serves as base. Following scenes overwrite components with identical identifiers, see [Collision Scene Assembly](Collision Scene Assembly). 
-     * @type {Array<string>}
-     * @memberof CollisionSceneAssembly
-     */
-    'stored_scenes'?: Array<string>;
-    /**
-     * 
-     * @type {CollisionScene}
-     * @memberof CollisionSceneAssembly
-     */
-    'scene'?: CollisionScene;
-    /**
-     * Add stored colliders to the scene via their identifiers. The colliders are added to the the origin of the scene. 
-     * @type {Array<string>}
-     * @memberof CollisionSceneAssembly
-     */
-    'stored_colliders'?: Array<string>;
-    /**
-     * A collection of identifiable colliders.
-     * @type {{ [key: string]: Collider; }}
-     * @memberof CollisionSceneAssembly
-     */
-    'colliders'?: { [key: string]: Collider; };
     /**
-     * Maps a Wandelbots NOVA motion group to its assembly configuration in the collision scene. Key must be a motion group identifier.  A collision motion group defines a motion group in the collision scene.  The motion group is attached to the origin of the scene. To relocate the motion group, configure its mounting offset on the physical controller. This ensures that the definition of motion commands and collision scenes use the same coordinate system. The kinematic chain looks like this: - Origin >> Mounting >> Base >> Joint 0 >> Link 0 >> Joint 1 >> […] >> TCP  A `tool` is treated like another link attached to the end (flange) of the kinematic chain. All tool colliders are described in the flange frame. 
-     * @type {{ [key: string]: CollisionMotionGroupAssembly; }}
-     * @memberof CollisionSceneAssembly
+     * If true, self-collision detection is enabled for the motion group.  Self-collision detection checks if links in the kinematic chain of the motion group collide with each other. Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. The tool is treated like a link at the end of the kinematic chain. It is checked against all links except the last one.  Default is true. 
+     * @type {boolean}
+     * @memberof CollisionSetup
      */
-    'motion_groups'?: { [key: string]: CollisionMotionGroupAssembly; };
+    'self_collision_detection'?: boolean;
 }
 /**
  * Comparator for the comparison of two values. The comparator is used to compare two values and return a boolean result. The default comparator is unknown. 
@@ -851,6 +965,25 @@ export interface ContainerImageSecretsInner {
      */
     'name': string;
 }
+/**
+ * Additional resources that the application requires.
+ * @export
+ * @interface ContainerResources
+ */
+export interface ContainerResources {
+    /**
+     * Number of GPUs the application requires.
+     * @type {number}
+     * @memberof ContainerResources
+     */
+    'intel_gpu'?: number;
+    /**
+     * The maximum memory allocated to this application.
+     * @type {string}
+     * @memberof ContainerResources
+     */
+    'memory_limit'?: string;
+}
 /**
  * The path and capacity of a volume that retains data across application restarts. The maximal requestable capacity is 300Mi. If you need more capacity consider using [storeObject](storeObject). 
  * @export
@@ -1127,24 +1260,126 @@ export type Direction = typeof Direction[keyof typeof Direction];
 
 
 /**
- * 
+ * The provided joint data does not match the expected number of joints for this motion group. 
  * @export
- * @interface EndOfTrajectory
+ * @interface ErrorInvalidJointCount
  */
-export interface EndOfTrajectory {
+export interface ErrorInvalidJointCount {
+    /**
+     * The expected number of joints for this motion group. 
+     * @type {number}
+     * @memberof ErrorInvalidJointCount
+     */
+    'expected_joint_count': number;
+    /**
+     * The number of provided joints. 
+     * @type {number}
+     * @memberof ErrorInvalidJointCount
+     */
+    'provided_joint_count': number;
     /**
      * 
      * @type {string}
-     * @memberof EndOfTrajectory
+     * @memberof ErrorInvalidJointCount
      */
-    'kind': EndOfTrajectoryKindEnum;
+    'error_feedback_name': ErrorInvalidJointCountErrorFeedbackNameEnum;
 }
 
-export const EndOfTrajectoryKindEnum = {
-    EndOfTrajectory: 'END_OF_TRAJECTORY'
+export const ErrorInvalidJointCountErrorFeedbackNameEnum = {
+    ErrorInvalidJointCount: 'ErrorInvalidJointCount'
+} as const;
+
+export type ErrorInvalidJointCountErrorFeedbackNameEnum = typeof ErrorInvalidJointCountErrorFeedbackNameEnum[keyof typeof ErrorInvalidJointCountErrorFeedbackNameEnum];
+
+/**
+ * A reference joint position (start or target) exceeds the configured joint limits. 
+ * @export
+ * @interface ErrorJointLimitExceeded
+ */
+export interface ErrorJointLimitExceeded {
+    /**
+     * Index of the joint exceeding its limits (0-based). 
+     * @type {number}
+     * @memberof ErrorJointLimitExceeded
+     */
+    'joint_index'?: number;
+    /**
+     * 
+     * @type {Array<number>}
+     * @memberof ErrorJointLimitExceeded
+     */
+    'joint_position'?: Array<number>;
+    /**
+     * 
+     * @type {string}
+     * @memberof ErrorJointLimitExceeded
+     */
+    'error_feedback_name': ErrorJointLimitExceededErrorFeedbackNameEnum;
+}
+
+export const ErrorJointLimitExceededErrorFeedbackNameEnum = {
+    ErrorJointLimitExceeded: 'ErrorJointLimitExceeded'
+} as const;
+
+export type ErrorJointLimitExceededErrorFeedbackNameEnum = typeof ErrorJointLimitExceededErrorFeedbackNameEnum[keyof typeof ErrorJointLimitExceededErrorFeedbackNameEnum];
+
+/**
+ * A reference joint position (e.g. start or target joint position) results in collisions that prevent processing. 
+ * @export
+ * @interface ErrorJointPositionCollision
+ */
+export interface ErrorJointPositionCollision {
+    /**
+     * 
+     * @type {Array<Collision>}
+     * @memberof ErrorJointPositionCollision
+     */
+    'collisions'?: Array<Collision>;
+    /**
+     * 
+     * @type {Array<number>}
+     * @memberof ErrorJointPositionCollision
+     */
+    'joint_position'?: Array<number>;
+    /**
+     * 
+     * @type {string}
+     * @memberof ErrorJointPositionCollision
+     */
+    'error_feedback_name': ErrorJointPositionCollisionErrorFeedbackNameEnum;
+}
+
+export const ErrorJointPositionCollisionErrorFeedbackNameEnum = {
+    ErrorJointPositionCollision: 'ErrorJointPositionCollision'
+} as const;
+
+export type ErrorJointPositionCollisionErrorFeedbackNameEnum = typeof ErrorJointPositionCollisionErrorFeedbackNameEnum[keyof typeof ErrorJointPositionCollisionErrorFeedbackNameEnum];
+
+/**
+ * The collision-free planning algorithm reached its maximum iteration limit without finding a valid path. Increase max_iterations or modify the start/target positions. 
+ * @export
+ * @interface ErrorMaxIterationsExceeded
+ */
+export interface ErrorMaxIterationsExceeded {
+    /**
+     * The maximum number of iterations that was reached. 
+     * @type {number}
+     * @memberof ErrorMaxIterationsExceeded
+     */
+    'max_iterations'?: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof ErrorMaxIterationsExceeded
+     */
+    'error_feedback_name': ErrorMaxIterationsExceededErrorFeedbackNameEnum;
+}
+
+export const ErrorMaxIterationsExceededErrorFeedbackNameEnum = {
+    ErrorMaxIterationsExceeded: 'ErrorMaxIterationsExceeded'
 } as const;
 
-export type EndOfTrajectoryKindEnum = typeof EndOfTrajectoryKindEnum[keyof typeof EndOfTrajectoryKindEnum];
+export type ErrorMaxIterationsExceededErrorFeedbackNameEnum = typeof ErrorMaxIterationsExceededErrorFeedbackNameEnum[keyof typeof ErrorMaxIterationsExceededErrorFeedbackNameEnum];
 
 /**
  * Details about the state of the motion execution. The details are either for a jogging or a trajectory. If NOVA is not controlling this motion group at the moment, this field is omitted. 
@@ -1423,46 +1658,125 @@ 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;
-}
-/**
- * 
- * @export
+    'tcp_offset'?: Pose;
+    /**
+     * Offset from the world frame to the motion group base.
+     * @type {Pose}
+     * @memberof ForwardKinematicsRequest
+     */
+    'mounting'?: Pose;
+}
+/**
+ * 
+ * @export
+ * @interface ForwardKinematicsResponse
+ */
+export interface ForwardKinematicsResponse {
+    /**
+     * List of computed TCP poses corresponding to the input joint positions. 
+     * @type {Array<Pose>}
+     * @memberof ForwardKinematicsResponse
+     */
+    'tcp_poses': Array<Pose>;
+}
+/**
+ * 
+ * @export
+ * @interface ForwardKinematicsValidationError
+ */
+export interface ForwardKinematicsValidationError {
+    /**
+     * 
+     * @type {Array<ValidationErrorLocInner>}
+     * @memberof ForwardKinematicsValidationError
+     */
+    'loc': Array<ValidationErrorLocInner>;
+    /**
+     * 
+     * @type {string}
+     * @memberof ForwardKinematicsValidationError
+     */
+    'msg': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof ForwardKinematicsValidationError
+     */
+    'type': string;
+    /**
+     * 
+     * @type {{ [key: string]: any; }}
+     * @memberof ForwardKinematicsValidationError
+     */
+    'input': { [key: string]: any; };
+    /**
+     * 
+     * @type {ErrorInvalidJointCount}
+     * @memberof ForwardKinematicsValidationError
+     */
+    'data'?: ErrorInvalidJointCount;
+}
+/**
+ * 
+ * @export
+ * @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 {
@@ -1947,6 +2261,19 @@ export interface InvalidDofInvalidDof {
      */
     'joint_position'?: Array<number>;
 }
+/**
+ * 
+ * @export
+ * @interface InverseKinematics422Response
+ */
+export interface InverseKinematics422Response {
+    /**
+     * 
+     * @type {Array<InverseKinematicsValidationError>}
+     * @memberof InverseKinematics422Response
+     */
+    'detail'?: Array<InverseKinematicsValidationError>;
+}
 /**
  * 
  * @export
@@ -1984,11 +2311,11 @@ export interface InverseKinematicsRequest {
      */
     'joint_position_limits'?: Array<LimitRange>;
     /**
-     * Collision scenes to be respected by the motion planner. Each contains the single motion group which is planned for. Scenes are checked individually along the trajectory and independently of other scenes. To respect the safety zones of the controller, fetch the safety zones, link and tool shapes from the controller and add one scene made up of those. To respect the safety zones of the controller and check for collision: 1. Fetch the safety zones, link and tool shapes from the controller. 2. Add the fetched zones, links and tools to a scene. 3. Create other scenes from your own 3D data as needed. 4. Execute this endpoint. 5. The response highlights the scenes in which a collision was detected by key. 
-     * @type {{ [key: string]: SingleMotionGroupCollisionScene; }}
+     * Collision layers to be respected by the motion planner when planning for a single motion group. Each setup represents one layer, e.g. the safety zones and shapes or a fine grained tool and workpiece model. Layers are checked individually along the trajectory and independently of other layers.  To respect the safety zones of the controller and check for collision: 1. Fetch the safety zones, link and tool shapes from the controller. 2. Add the fetched zones, links and tools to a layer. 3. Create other layers from your own 3D data as needed. 4. Plan trajectory. 5. The response highlights the layer in which a collision was detected by key. 
+     * @type {{ [key: string]: CollisionSetup; }}
      * @memberof InverseKinematicsRequest
      */
-    'collision_scenes'?: { [key: string]: SingleMotionGroupCollisionScene; };
+    'collision_setups'?: { [key: string]: CollisionSetup; };
 }
 /**
  * 
@@ -2003,6 +2330,50 @@ export interface InverseKinematicsResponse {
      */
     'joints': Array<Array<Array<number>>>;
 }
+/**
+ * 
+ * @export
+ * @interface InverseKinematicsValidationError
+ */
+export interface InverseKinematicsValidationError {
+    /**
+     * 
+     * @type {Array<ValidationErrorLocInner>}
+     * @memberof InverseKinematicsValidationError
+     */
+    'loc': Array<ValidationErrorLocInner>;
+    /**
+     * 
+     * @type {string}
+     * @memberof InverseKinematicsValidationError
+     */
+    'msg': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof InverseKinematicsValidationError
+     */
+    'type': string;
+    /**
+     * 
+     * @type {{ [key: string]: any; }}
+     * @memberof InverseKinematicsValidationError
+     */
+    'input': { [key: string]: any; };
+    /**
+     * 
+     * @type {InverseKinematicsValidationErrorAllOfData}
+     * @memberof InverseKinematicsValidationError
+     */
+    'data'?: InverseKinematicsValidationErrorAllOfData;
+}
+/**
+ * @type InverseKinematicsValidationErrorAllOfData
+ * Optional data further specifying the validation error. 
+ * @export
+ */
+export type InverseKinematicsValidationErrorAllOfData = { error_feedback_name: 'ErrorInvalidJointCount' } & ErrorInvalidJointCount | { error_feedback_name: 'ErrorJointLimitExceeded' } & ErrorJointLimitExceeded;
+
 /**
  * State of jogging execution. This state is sent during jogging movement, response-rate closest to the nearest multiple of controller step-rate but not exceeding the configured rate. The jogging state can be one of the following: - RUNNING: Jogging is active. - PAUSED_BY_USER: User has paused jogging. - PAUSED_NEAR_JOINT_LIMIT: Jogging was paused because a joint is is near its limit. - PAUSED_NEAR_COLLISION: Jogging was paused because the motion group neared a collision. - PAUSED_ON_IO: Jogging was paused because of an I/O event. 
  * @export
@@ -2033,7 +2404,119 @@ export type JoggingDetailsKindEnum = typeof JoggingDetailsKindEnum[keyof typeof
  * @type JoggingDetailsState
  * @export
  */
-export type JoggingDetailsState = PausedByUser | PausedNearCollision | PausedNearJointLimit | PausedOnIO | Running;
+export type JoggingDetailsState = JoggingPausedByUser | JoggingPausedNearCollision | JoggingPausedNearJointLimit | JoggingPausedOnIO | JoggingRunning;
+
+/**
+ * 
+ * @export
+ * @interface JoggingPausedByUser
+ */
+export interface JoggingPausedByUser {
+    /**
+     * 
+     * @type {string}
+     * @memberof JoggingPausedByUser
+     */
+    'kind': JoggingPausedByUserKindEnum;
+}
+
+export const JoggingPausedByUserKindEnum = {
+    PausedByUser: 'PAUSED_BY_USER'
+} as const;
+
+export type JoggingPausedByUserKindEnum = typeof JoggingPausedByUserKindEnum[keyof typeof JoggingPausedByUserKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface JoggingPausedNearCollision
+ */
+export interface JoggingPausedNearCollision {
+    /**
+     * 
+     * @type {string}
+     * @memberof JoggingPausedNearCollision
+     */
+    'kind': JoggingPausedNearCollisionKindEnum;
+    /**
+     * 
+     * @type {string}
+     * @memberof JoggingPausedNearCollision
+     */
+    'description': string;
+}
+
+export const JoggingPausedNearCollisionKindEnum = {
+    PausedNearCollision: 'PAUSED_NEAR_COLLISION'
+} as const;
+
+export type JoggingPausedNearCollisionKindEnum = typeof JoggingPausedNearCollisionKindEnum[keyof typeof JoggingPausedNearCollisionKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface JoggingPausedNearJointLimit
+ */
+export interface JoggingPausedNearJointLimit {
+    /**
+     * 
+     * @type {string}
+     * @memberof JoggingPausedNearJointLimit
+     */
+    'kind': JoggingPausedNearJointLimitKindEnum;
+    /**
+     * 
+     * @type {Array<number>}
+     * @memberof JoggingPausedNearJointLimit
+     */
+    'joint_indices': Array<number>;
+}
+
+export const JoggingPausedNearJointLimitKindEnum = {
+    PausedNearJointLimit: 'PAUSED_NEAR_JOINT_LIMIT'
+} as const;
+
+export type JoggingPausedNearJointLimitKindEnum = typeof JoggingPausedNearJointLimitKindEnum[keyof typeof JoggingPausedNearJointLimitKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface JoggingPausedOnIO
+ */
+export interface JoggingPausedOnIO {
+    /**
+     * 
+     * @type {string}
+     * @memberof JoggingPausedOnIO
+     */
+    'kind': JoggingPausedOnIOKindEnum;
+}
+
+export const JoggingPausedOnIOKindEnum = {
+    PausedOnIo: 'PAUSED_ON_IO'
+} as const;
+
+export type JoggingPausedOnIOKindEnum = typeof JoggingPausedOnIOKindEnum[keyof typeof JoggingPausedOnIOKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface JoggingRunning
+ */
+export interface JoggingRunning {
+    /**
+     * 
+     * @type {string}
+     * @memberof JoggingRunning
+     */
+    'kind': JoggingRunningKindEnum;
+}
+
+export const JoggingRunningKindEnum = {
+    Running: 'RUNNING'
+} as const;
+
+export type JoggingRunningKindEnum = typeof JoggingRunningKindEnum[keyof typeof JoggingRunningKindEnum];
 
 /**
  * 
@@ -2473,6 +2956,32 @@ export const Manufacturer = {
 export type Manufacturer = typeof Manufacturer[keyof typeof Manufacturer];
 
 
+/**
+ * Midpoint insertion algorithm configuration for collision-free path planning. This algorithm iteratively inserts midpoints between the start and target joint position to find collision-free paths. 
+ * @export
+ * @interface MidpointInsertionAlgorithm
+ */
+export interface MidpointInsertionAlgorithm {
+    /**
+     * Algorithm discriminator. 
+     * @type {string}
+     * @memberof MidpointInsertionAlgorithm
+     */
+    'algorithm_name': MidpointInsertionAlgorithmAlgorithmNameEnum;
+    /**
+     * Maximum number of iterations for the midpoint insertion algorithm. Higher values increase likelyhood of success, but also computation time (linear). 
+     * @type {number}
+     * @memberof MidpointInsertionAlgorithm
+     */
+    'max_iterations'?: number;
+}
+
+export const MidpointInsertionAlgorithmAlgorithmNameEnum = {
+    MidpointInsertionAlgorithm: 'MidpointInsertionAlgorithm'
+} as const;
+
+export type MidpointInsertionAlgorithmAlgorithmNameEnum = typeof MidpointInsertionAlgorithmAlgorithmNameEnum[keyof typeof MidpointInsertionAlgorithmAlgorithmNameEnum];
+
 /**
  * 
  * @export
@@ -2653,6 +3162,55 @@ export interface MotionGroupJoints {
      */
     'torques'?: Array<number>;
 }
+/**
+ * 
+ * @export
+ * @interface MotionGroupSetup
+ */
+export interface MotionGroupSetup {
+    /**
+     * String identifiying the model of a motion group.
+     * @type {string}
+     * @memberof MotionGroupSetup
+     */
+    'motion_group_model': string;
+    /**
+     * [ms] cycle time of the motion group controller. A trajectory for this motion group should be computed to this resolution.
+     * @type {number}
+     * @memberof MotionGroupSetup
+     */
+    'cycle_time': number;
+    /**
+     * The offset from the world frame to the motion group base.
+     * @type {Pose}
+     * @memberof MotionGroupSetup
+     */
+    'mounting'?: Pose;
+    /**
+     * 
+     * @type {Pose}
+     * @memberof MotionGroupSetup
+     */
+    'tcp_offset'?: Pose;
+    /**
+     * 
+     * @type {LimitSet}
+     * @memberof MotionGroupSetup
+     */
+    'global_limits'?: LimitSet;
+    /**
+     * 
+     * @type {Payload}
+     * @memberof MotionGroupSetup
+     */
+    'payload'?: Payload;
+    /**
+     * Collision layers to be respected by the motion planner when planning for a single motion group. Each setup represents one layer, e.g. the safety zones and shapes or a fine grained tool and workpiece model. Layers are checked individually along the trajectory and independently of other layers.  To respect the safety zones of the controller and check for collision: 1. Fetch the safety zones, link and tool shapes from the controller. 2. Add the fetched zones, links and tools to a layer. 3. Create other layers from your own 3D data as needed. 4. Plan trajectory. 5. The response highlights the layer in which a collision was detected by key. 
+     * @type {{ [key: string]: CollisionSetup; }}
+     * @memberof MotionGroupSetup
+     */
+    'collision_setups'?: { [key: string]: CollisionSetup; };
+}
 /**
  * Presents the current state of the motion group.
  * @export
@@ -3187,146 +3745,110 @@ export interface PauseOnIO {
 /**
  * 
  * @export
- * @interface PausedByRequest
+ * @interface Payload
  */
-export interface PausedByRequest {
+export interface Payload {
     /**
      * 
      * @type {string}
-     * @memberof PausedByRequest
+     * @memberof Payload
      */
-    'kind': PausedByRequestKindEnum;
-}
-
-export const PausedByRequestKindEnum = {
-    PausedByUser: 'PAUSED_BY_USER'
-} as const;
-
-export type PausedByRequestKindEnum = typeof PausedByRequestKindEnum[keyof typeof PausedByRequestKindEnum];
-
-/**
- * 
- * @export
- * @interface PausedByUser
- */
-export interface PausedByUser {
+    'name': string;
     /**
-     * 
-     * @type {string}
-     * @memberof PausedByUser
-     */
-    'kind': PausedByUserKindEnum;
-}
-
-export const PausedByUserKindEnum = {
-    PausedByUser: 'PAUSED_BY_USER'
-} as const;
-
-export type PausedByUserKindEnum = typeof PausedByUserKindEnum[keyof typeof PausedByUserKindEnum];
-
-/**
- * 
- * @export
- * @interface PausedNearCollision
- */
-export interface PausedNearCollision {
+     * Mass of payload in [kg].
+     * @type {number}
+     * @memberof Payload
+     */
+    'payload': number;
     /**
-     * 
-     * @type {string}
-     * @memberof PausedNearCollision
+     * A three-dimensional vector [x, y, z] with double precision. 
+     * @type {Array<number>}
+     * @memberof Payload
      */
-    'kind': PausedNearCollisionKindEnum;
+    'center_of_mass'?: Array<number>;
     /**
-     * 
-     * @type {string}
-     * @memberof PausedNearCollision
+     * A three-dimensional vector [x, y, z] with double precision. 
+     * @type {Array<number>}
+     * @memberof Payload
      */
-    'description': string;
+    'moment_of_inertia'?: Array<number>;
 }
-
-export const PausedNearCollisionKindEnum = {
-    PausedNearCollision: 'PAUSED_NEAR_COLLISION'
-} as const;
-
-export type PausedNearCollisionKindEnum = typeof PausedNearCollisionKindEnum[keyof typeof PausedNearCollisionKindEnum];
-
 /**
  * 
  * @export
- * @interface PausedNearJointLimit
+ * @interface Plan422Response
  */
-export interface PausedNearJointLimit {
-    /**
-     * 
-     * @type {string}
-     * @memberof PausedNearJointLimit
-     */
-    'kind': PausedNearJointLimitKindEnum;
+export interface Plan422Response {
     /**
      * 
-     * @type {Array<number>}
-     * @memberof PausedNearJointLimit
+     * @type {Array<PlanValidationError>}
+     * @memberof Plan422Response
      */
-    'joint_indices': Array<number>;
+    'detail'?: Array<PlanValidationError>;
 }
-
-export const PausedNearJointLimitKindEnum = {
-    PausedNearJointLimit: 'PAUSED_NEAR_JOINT_LIMIT'
-} as const;
-
-export type PausedNearJointLimitKindEnum = typeof PausedNearJointLimitKindEnum[keyof typeof PausedNearJointLimitKindEnum];
-
 /**
- * 
+ * Response when collision-free trajectory planning fails. Contains specific feedback about why the planning failed. 
  * @export
- * @interface PausedOnIO
+ * @interface PlanCollisionFreeFailedResponse
  */
-export interface PausedOnIO {
+export interface PlanCollisionFreeFailedResponse {
     /**
      * 
-     * @type {string}
-     * @memberof PausedOnIO
+     * @type {ErrorMaxIterationsExceeded}
+     * @memberof PlanCollisionFreeFailedResponse
      */
-    'kind': PausedOnIOKindEnum;
+    'error_feedback': ErrorMaxIterationsExceeded;
 }
-
-export const PausedOnIOKindEnum = {
-    PausedOnIo: 'PAUSED_ON_IO'
-} as const;
-
-export type PausedOnIOKindEnum = typeof PausedOnIOKindEnum[keyof typeof PausedOnIOKindEnum];
-
 /**
  * 
  * @export
- * @interface Payload
+ * @interface PlanCollisionFreeRequest
  */
-export interface Payload {
+export interface PlanCollisionFreeRequest {
     /**
-     * 
-     * @type {string}
-     * @memberof Payload
+     * The data to assemble the robot setup can be retrieved from [getMotionGroupDescription](getMotionGroupDescription) endpoint.
+     * @type {MotionGroupSetup}
+     * @memberof PlanCollisionFreeRequest
      */
-    'name': string;
+    'motion_group_setup': MotionGroupSetup;
     /**
-     * Mass of payload in [kg].
-     * @type {number}
-     * @memberof Payload
+     * 
+     * @type {Array<number>}
+     * @memberof PlanCollisionFreeRequest
      */
-    'payload': number;
+    'start_joint_position': Array<number>;
     /**
-     * A three-dimensional vector [x, y, z] with double precision. 
+     * 
      * @type {Array<number>}
-     * @memberof Payload
+     * @memberof PlanCollisionFreeRequest
      */
-    'center_of_mass'?: Array<number>;
+    'target': Array<number>;
     /**
-     * A three-dimensional vector [x, y, z] with double precision. 
-     * @type {Array<number>}
-     * @memberof Payload
+     * 
+     * @type {CollisionFreeAlgorithm}
+     * @memberof PlanCollisionFreeRequest
      */
-    'moment_of_inertia'?: Array<number>;
+    '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
@@ -3366,10 +3888,10 @@ export type PlanTrajectoryFailedResponseErrorFeedback = FeedbackCollision | Feed
 export interface PlanTrajectoryRequest {
     /**
      * The data to assemble the robot setup can be retrieved from [getMotionGroupDescription](getMotionGroupDescription) endpoint.
-     * @type {RobotSetup}
+     * @type {MotionGroupSetup}
      * @memberof PlanTrajectoryRequest
      */
-    'robot_setup': RobotSetup;
+    'motion_group_setup': MotionGroupSetup;
     /**
      * 
      * @type {Array<number>}
@@ -3402,6 +3924,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
@@ -3494,226 +4060,448 @@ 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 ProfinetDescription
+     */
+    'vendor_id': string;
+    /**
+     * The device identifier of the PROFINET device, identifying the specific device within the vendor\'s range. 
+     * @type {string}
+     * @memberof ProfinetDescription
+     */
+    'device_id': string;
     /**
      * 
+     * @type {Array<ProfinetSlotDescription>}
+     * @memberof ProfinetDescription
+     */
+    'slots'?: Array<ProfinetSlotDescription>;
+    /**
+     * Name of the PROFINET device
      * @type {string}
-     * @memberof Rectangle
+     * @memberof ProfinetDescription
      */
-    'shape_type': RectangleShapeTypeEnum;
+    'device_name'?: string;
     /**
-     * The dimension in x-direction in [mm].
+     * IP address for the PROFINET device
+     * @type {string}
+     * @memberof ProfinetDescription
+     */
+    'ip'?: string;
+}
+/**
+ * 
+ * @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 Rectangle
+     * @memberof ProfinetIO
      */
-    'size_x': number;
+    'byte_address': number;
     /**
-     * The dimension in y-direction in [mm].
+     * 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 Rectangle
+     * @memberof ProfinetIO
      */
-    'size_y': number;
+    '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 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. 
+ * 
  * @export
- * @interface RectangularCapsule
+ * @interface ProfinetIOData
  */
-export interface RectangularCapsule {
+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 RectangularCapsule
+     * @memberof ProfinetIOData
      */
-    'shape_type': RectangularCapsuleShapeTypeEnum;
+    'name': string;
     /**
-     * The radius of the inner spheres in [mm].
-     * @type {number}
-     * @memberof RectangularCapsule
+     * 
+     * @type {ProfinetIOTypeEnum}
+     * @memberof ProfinetIOData
      */
-    'radius': number;
+    'type': ProfinetIOTypeEnum;
     /**
-     * The distance of the sphere center in x-direction in [mm].
+     * 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 RectangularCapsule
+     * @memberof ProfinetIOData
      */
-    'sphere_center_distance_x': number;
+    'byte_address': number;
     /**
-     * The distance of the sphere center in y-direction in [mm].
+     * 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 RectangularCapsule
+     * @memberof ProfinetIOData
      */
-    'sphere_center_distance_y': number;
+    'bit_address'?: number;
 }
 
-export const RectangularCapsuleShapeTypeEnum = {
-    RectangularCapsule: 'rectangular_capsule'
+
+/**
+ * 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 RectangularCapsuleShapeTypeEnum = typeof RectangularCapsuleShapeTypeEnum[keyof typeof RectangularCapsuleShapeTypeEnum];
+export type ProfinetIODirection = typeof ProfinetIODirection[keyof typeof ProfinetIODirection];
+
 
 /**
- * The channel that defines what a new Wandelbots NOVA version is.    * `next` the over all latest version   * `stable` newes patch of the current version 
+ * Value type of the PROFINET input/output. 
  * @export
  * @enum {string}
  */
 
-export const ReleaseChannel = {
-    Stable: 'stable',
-    Next: 'next'
+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 ReleaseChannel = typeof ReleaseChannel[keyof typeof ReleaseChannel];
+export type ProfinetIOTypeEnum = typeof ProfinetIOTypeEnum[keyof typeof ProfinetIOTypeEnum];
 
 
 /**
- * The configuration of a physical or virtual robot controller.
+ * 
  * @export
- * @interface RobotController
+ * @interface ProfinetInputOutputConfig
  */
-export interface RobotController {
+export interface ProfinetInputOutputConfig {
     /**
-     * A unique name of the Controller inside the Cell. It must be a valid k8s label name as defined by [RFC 1035](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#rfc-1035-label-names).
+     * Content of the input output configuration file.
      * @type {string}
-     * @memberof RobotController
+     * @memberof ProfinetInputOutputConfig
      */
-    'name': string;
+    'config': string;
     /**
-     * 
-     * @type {RobotControllerConfiguration}
-     * @memberof RobotController
+     * Offset in bytes for the input data.
+     * @type {number}
+     * @memberof ProfinetInputOutputConfig
      */
-    'configuration': RobotControllerConfiguration;
+    'input_offset': number;
+    /**
+     * Offset in bytes for the output data.
+     * @type {number}
+     * @memberof ProfinetInputOutputConfig
+     */
+    'output_offset': number;
 }
 /**
- * @type RobotControllerConfiguration
- * @export
- */
-export type RobotControllerConfiguration = AbbController | FanucController | KukaController | UniversalrobotsController | VirtualController | YaskawaController;
-
-/**
- * Returns the whole current state of robot controller.
+ * 
  * @export
- * @interface RobotControllerState
+ * @interface ProfinetSlotDescription
  */
-export interface RobotControllerState {
+export interface ProfinetSlotDescription {
     /**
-     * Timestamp indicating when the represented information was received from the robot controller.
-     * @type {string}
-     * @memberof RobotControllerState
+     * The number of the PROFINET slot. 
+     * @type {number}
+     * @memberof ProfinetSlotDescription
      */
-    'timestamp': string;
+    'number': number;
     /**
-     * Sequence number of the controller state. It starts with 0 upon establishing the connection with a physical controller. The sequence number is reset when the connection to the physical controller is closed and re-established. 
+     * The API number of the PROFINET input, used to identify the specific API for the input. 
      * @type {number}
-     * @memberof RobotControllerState
+     * @memberof ProfinetSlotDescription
      */
-    'sequence_number': number;
+    'api': number;
     /**
-     * Identifier of the configured robot controller.
-     * @type {string}
-     * @memberof RobotControllerState
+     * An array of PROFINET subslots. 
+     * @type {Array<ProfinetSubSlotDescription>}
+     * @memberof ProfinetSlotDescription
      */
-    'controller': string;
+    'subslots': Array<ProfinetSubSlotDescription>;
+}
+/**
+ * 
+ * @export
+ * @interface ProfinetSubSlotDescription
+ */
+export interface ProfinetSubSlotDescription {
     /**
-     * 
-     * @type {OperationMode}
-     * @memberof RobotControllerState
+     * The identifier of the PROFINET subslot. 
+     * @type {number}
+     * @memberof ProfinetSubSlotDescription
      */
-    'operation_mode': OperationMode;
+    'number': number;
     /**
-     * 
-     * @type {SafetyStateType}
-     * @memberof RobotControllerState
+     * The length in bytes of the PROFINET input. 
+     * @type {number}
+     * @memberof ProfinetSubSlotDescription
      */
-    'safety_state': SafetyStateType;
+    'input_length': number;
     /**
-     * If made available by the robot controller, returns the current velocity override in [percentage] for movements adjusted on robot control panel. Valid value range: 1 - 100. 
+     * The length in bytes of the PROFINET output. 
      * @type {number}
-     * @memberof RobotControllerState
+     * @memberof ProfinetSubSlotDescription
      */
-    'velocity_override'?: number;
+    '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 {
     /**
-     * State of indicated motion groups. In case of state request via controller all configured motion groups are returned. In case of executing a motion only the affected motion groups are returned. 
-     * @type {Array<MotionGroupState>}
-     * @memberof RobotControllerState
+     * Algorithm discriminator. 
+     * @type {string}
+     * @memberof RRTConnectAlgorithm
      */
-    'motion_groups': Array<MotionGroupState>;
+    '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 RobotSetup
+ * @interface Rectangle
  */
-export interface RobotSetup {
+export interface Rectangle {
     /**
-     * String identifiying the model of a motion group.
+     * 
      * @type {string}
-     * @memberof RobotSetup
+     * @memberof Rectangle
      */
-    'motion_group_model': string;
+    'shape_type': RectangleShapeTypeEnum;
     /**
-     * [ms] cycle time of the motion group controller. A trajectory for this motion group should be computed to this resolution.
+     * The dimension in x-direction in [mm].
      * @type {number}
-     * @memberof RobotSetup
+     * @memberof Rectangle
      */
-    'cycle_time': number;
+    'size_x': number;
     /**
-     * The offset from the world frame to the motion group base.
-     * @type {Pose}
-     * @memberof RobotSetup
+     * The dimension in y-direction in [mm].
+     * @type {number}
+     * @memberof Rectangle
      */
-    'mounting'?: Pose;
+    '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. 
+ * @export
+ * @interface RectangularCapsule
+ */
+export interface RectangularCapsule {
     /**
      * 
-     * @type {Pose}
-     * @memberof RobotSetup
+     * @type {string}
+     * @memberof RectangularCapsule
      */
-    'tcp_offset'?: Pose;
+    'shape_type': RectangularCapsuleShapeTypeEnum;
+    /**
+     * The radius of the inner spheres in [mm].
+     * @type {number}
+     * @memberof RectangularCapsule
+     */
+    'radius': number;
+    /**
+     * The distance of the sphere center in x-direction in [mm].
+     * @type {number}
+     * @memberof RectangularCapsule
+     */
+    'sphere_center_distance_x': number;
+    /**
+     * The distance of the sphere center in y-direction in [mm].
+     * @type {number}
+     * @memberof RectangularCapsule
+     */
+    'sphere_center_distance_y': number;
+}
+
+export const RectangularCapsuleShapeTypeEnum = {
+    RectangularCapsule: 'rectangular_capsule'
+} as const;
+
+export type RectangularCapsuleShapeTypeEnum = typeof RectangularCapsuleShapeTypeEnum[keyof typeof RectangularCapsuleShapeTypeEnum];
+
+/**
+ * The channel that defines what a new Wandelbots NOVA version is.    * `next` the over all latest version   * `stable` newes patch of the current version 
+ * @export
+ * @enum {string}
+ */
+
+export const ReleaseChannel = {
+    Stable: 'stable',
+    Next: 'next'
+} as const;
+
+export type ReleaseChannel = typeof ReleaseChannel[keyof typeof ReleaseChannel];
+
+
+/**
+ * The configuration of a physical or virtual robot controller.
+ * @export
+ * @interface RobotController
+ */
+export interface RobotController {
+    /**
+     * Unique name of controller within the cell. It must be a valid k8s label name as defined by [RFC 1035](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#rfc-1035-label-names). 
+     * @type {string}
+     * @memberof RobotController
+     */
+    'name': string;
     /**
      * 
-     * @type {LimitSet}
-     * @memberof RobotSetup
+     * @type {RobotControllerConfiguration}
+     * @memberof RobotController
      */
-    'global_limits'?: LimitSet;
+    'configuration': RobotControllerConfiguration;
+}
+/**
+ * @type RobotControllerConfiguration
+ * @export
+ */
+export type RobotControllerConfiguration = AbbController | FanucController | KukaController | UniversalrobotsController | VirtualController | YaskawaController;
+
+/**
+ * Returns the whole current state of robot controller.
+ * @export
+ * @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}
+     * @memberof RobotControllerState
+     */
+    'timestamp': string;
+    /**
+     * Sequence number of the controller state. It starts with 0 upon establishing the connection with a physical controller. The sequence number is reset when the connection to the physical controller is closed and re-established. 
+     * @type {number}
+     * @memberof RobotControllerState
+     */
+    'sequence_number': number;
+    /**
+     * Identifier of the configured robot controller.
+     * @type {string}
+     * @memberof RobotControllerState
+     */
+    'controller': string;
     /**
      * 
-     * @type {Payload}
-     * @memberof RobotSetup
+     * @type {OperationMode}
+     * @memberof RobotControllerState
      */
-    'payload'?: Payload;
+    'operation_mode': OperationMode;
+    /**
+     * 
+     * @type {SafetyStateType}
+     * @memberof RobotControllerState
+     */
+    'safety_state': SafetyStateType;
+    /**
+     * If made available by the robot controller, returns the current velocity override in [percentage] for movements adjusted on robot control panel. Valid value range: 1 - 100. 
+     * @type {number}
+     * @memberof RobotControllerState
+     */
+    'velocity_override'?: number;
     /**
-     * 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
+     * State of indicated motion groups. In case of state request via controller all configured motion groups are returned. In case of executing a motion only the affected motion groups are returned. 
+     * @type {Array<MotionGroupState>}
+     * @memberof RobotControllerState
      */
-    'collision_scenes'?: { [key: string]: SingleMotionGroupCollisionScene; };
+    'motion_groups': Array<MotionGroupState>;
 }
+
+
 /**
- * The system mode of the robot system.  ### ROBOT_SYSTEM_MODE_UNDEFINED  Indicates that the robot controller is currently performing a mode transition.  ### ROBOT_SYSTEM_MODE_DISCONNECT  There is no communication with the robot controller at all. All connections are closed. No command is sent to the robot controller while in this mode. No input/output interaction is possible in this mode! All move requests will be rejected in this mode!  ### ROBOT_SYSTEM_MODE_MONITOR  A connection to the robot controller is established to only read the robot controller state. No command is sent to the robot controller while in this mode. It is possible to receive input/output information. All move requests will be rejected in this mode!  ### ROBOT_SYSTEM_MODE_CONTROL  An active connection is established with the robot controller and the robot system is cyclic commanded to stay in its actual position. The robot controller state is received in the cycle time of the robot controller. Requests via the MotionService and JoggingService will be processed and executed in this mode. Input/Output interaction is possible in this mode! **In this mode the robot system can be commanded to move.**  ### ROBOT_SYSTEM_MODE_FREE_DRIVE  Like ROBOT_SYSTEM_MODE_MONITOR a connection to the robot controller is established to only read the robot controller state. The difference is that the motion groups can be moved by the user (Free Drive). Thus, the servo motors are turned on. All move requests will be rejected in this mode! **This mode is not supported by every robot!** Use [getSupportedModes](getSupportedModes) to evaluate if the device support free drive. 
+ * Defines the current system mode of the robot system, including NOVA communicating with the robot controller.  ### MODE_CONTROLLER_NOT_CONFIGURED  No controller with the specified identifier is configured. Call [addRobotController](addRobotController) to register a controller.  ### MODE_INITIALIZING  Indicates that a connection to the robot controller is established or reestablished in case of a disconnect. On success, the controller is set to MODE_MONITOR. On failure, the initialization process is retried until successful or cancelled by the user.  ### MODE_MONITOR  Read-only mode with an active controller connection. - Receives robot state and I/O signals - Move requests are rejected - No commands are sent to the controller  ### MODE_CONTROL  Active control mode.  **Movement is possible in this mode**  The robot is cyclically commanded to hold its current position. The robot state is received in sync with the controller cycle. Motion and jogging requests are accepted and executed. Input/Output interaction is enabled.  ### MODE_FREE_DRIVE  Read-only mode with servo motors enabled for manual movement (Free Drive).  Move requests are rejected.  Not supported by all robots: Use [getSupportedModes](getSupportedModes) to check Free Drive availability. 
  * @export
  * @enum {string}
  */
 
 export const RobotSystemMode = {
-    RobotSystemModeUndefined: 'ROBOT_SYSTEM_MODE_UNDEFINED',
-    RobotSystemModeDisconnect: 'ROBOT_SYSTEM_MODE_DISCONNECT',
-    RobotSystemModeMonitor: 'ROBOT_SYSTEM_MODE_MONITOR',
-    RobotSystemModeControl: 'ROBOT_SYSTEM_MODE_CONTROL',
-    RobotSystemModeFreeDrive: 'ROBOT_SYSTEM_MODE_FREE_DRIVE'
+    ModeControllerNotConfigured: 'MODE_CONTROLLER_NOT_CONFIGURED',
+    ModeInitializing: 'MODE_INITIALIZING',
+    ModeMonitor: 'MODE_MONITOR',
+    ModeControl: 'MODE_CONTROL',
+    ModeFreeDrive: 'MODE_FREE_DRIVE'
 } as const;
 
 export type RobotSystemMode = typeof RobotSystemMode[keyof typeof RobotSystemMode];
@@ -3791,52 +4579,6 @@ export interface RobotTcpData {
 }
 
 
-/**
- * 
- * @export
- * @interface Running
- */
-export interface Running {
-    /**
-     * 
-     * @type {string}
-     * @memberof Running
-     */
-    'kind': RunningKindEnum;
-}
-
-export const RunningKindEnum = {
-    Running: 'RUNNING'
-} as const;
-
-export type RunningKindEnum = typeof RunningKindEnum[keyof typeof RunningKindEnum];
-
-/**
- * 
- * @export
- * @interface Running1
- */
-export interface Running1 {
-    /**
-     * 
-     * @type {string}
-     * @memberof Running1
-     */
-    'kind': Running1KindEnum;
-    /**
-     * Remaining time in milliseconds (ms) to reach the end of the motion.
-     * @type {number}
-     * @memberof Running1
-     */
-    'time_to_end': number;
-}
-
-export const Running1KindEnum = {
-    Running: 'RUNNING'
-} as const;
-
-export type Running1KindEnum = typeof Running1KindEnum[keyof typeof Running1KindEnum];
-
 /**
  * Current safety state of the configured robot controller. Operation modes in which the attached motion groups can be moved are: - SAFETY_STATE_NORMAL - SAFETY_STATE_REDUCED All other modes are considered as non-operational. 
  * @export
@@ -4011,37 +4753,6 @@ export const SettableRobotSystemMode = {
 export type SettableRobotSystemMode = typeof SettableRobotSystemMode[keyof typeof SettableRobotSystemMode];
 
 
-/**
- * 
- * @export
- * @interface SingleMotionGroupCollisionScene
- */
-export interface SingleMotionGroupCollisionScene {
-    /**
-     * A collection of identifiable colliders.
-     * @type {{ [key: string]: Collider; }}
-     * @memberof SingleMotionGroupCollisionScene
-     */
-    'static_colliders'?: { [key: string]: Collider; };
-    /**
-     * A link chain is a kinematic chain of links that is connected via joints. A motion group can be used to control the motion of the joints in a link chain.  A link is a group of colliders that is attached to the link reference frame.  The reference frame of a link is obtained after applying all sets of Denavit-Hartenberg-parameters from base to (including) the link index.  This means that the reference frame of the link is on the rotation axis of the next joint in the kinematic chain. Example: For a motion group with 2 joints, the collider reference frame (CRF) for link 1 is on the rotation axis of joint 2. The chain looks like: - Origin >> Mounting >> Base >> (CRF Base) Joint 0 >> Link 0 >> (CRF Link 0) Joint 1 >> Link 1 >> (CRF Link 1) Flange (CRF Tool) >> TCP  Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. 
-     * @type {Array<{ [key: string]: Collider; }>}
-     * @memberof SingleMotionGroupCollisionScene
-     */
-    'link_chain'?: Array<{ [key: string]: Collider; }>;
-    /**
-     * Defines the shape of a tool.  A tool is a dictionary of colliders.  All colliders that make up a tool are attached to the flange frame of the motion group. 
-     * @type {{ [key: string]: Collider; }}
-     * @memberof SingleMotionGroupCollisionScene
-     */
-    'tool'?: { [key: string]: Collider; };
-    /**
-     * If true, self-collision detection is enabled for the motion group. See LinkChain documentation for details. Default is true. 
-     * @type {boolean}
-     * @memberof SingleMotionGroupCollisionScene
-     */
-    'motion_group_self_collision_detection'?: boolean;
-}
 /**
  * 
  * @export
@@ -4100,7 +4811,7 @@ export interface StartMovementRequest {
      * @type {Direction}
      * @memberof StartMovementRequest
      */
-    'direction': Direction;
+    'direction'?: Direction;
     /**
      * Attaches a list of output commands to the trajectory. The outputs are set to the specified values right after the specified location was reached. If the specified location is located before the start location (forward direction: value is smaller, backward direction: value is bigger), the output is not set. 
      * @type {Array<IOValue>}
@@ -4407,7 +5118,27 @@ export type TrajectoryDetailsKindEnum = typeof TrajectoryDetailsKindEnum[keyof t
  * @type TrajectoryDetailsState
  * @export
  */
-export type TrajectoryDetailsState = EndOfTrajectory | PausedByRequest | PausedOnIO | Running1 | WaitForIO;
+export type TrajectoryDetailsState = TrajectoryEnded | TrajectoryPausedByUser | TrajectoryPausedOnIO | TrajectoryRunning | TrajectoryWaitForIO;
+
+/**
+ * 
+ * @export
+ * @interface TrajectoryEnded
+ */
+export interface TrajectoryEnded {
+    /**
+     * 
+     * @type {string}
+     * @memberof TrajectoryEnded
+     */
+    'kind': TrajectoryEndedKindEnum;
+}
+
+export const TrajectoryEndedKindEnum = {
+    EndOfTrajectory: 'END_OF_TRAJECTORY'
+} as const;
+
+export type TrajectoryEndedKindEnum = typeof TrajectoryEndedKindEnum[keyof typeof TrajectoryEndedKindEnum];
 
 /**
  * 
@@ -4436,21 +5167,107 @@ export const TrajectoryIdMessageTypeEnum = {
 export type TrajectoryIdMessageTypeEnum = typeof TrajectoryIdMessageTypeEnum[keyof typeof TrajectoryIdMessageTypeEnum];
 
 /**
- * The unit of input/output value.
+ * 
  * @export
- * @enum {string}
+ * @interface TrajectoryPausedByUser
  */
+export interface TrajectoryPausedByUser {
+    /**
+     * 
+     * @type {string}
+     * @memberof TrajectoryPausedByUser
+     */
+    'kind': TrajectoryPausedByUserKindEnum;
+}
 
-export const UnitType = {
-    UnitNone: 'UNIT_NONE',
-    UnitKilogram: 'UNIT_KILOGRAM',
-    UnitAmpere: 'UNIT_AMPERE',
-    UnitKelvin: 'UNIT_KELVIN',
-    UnitHertz: 'UNIT_HERTZ',
-    UnitNewton: 'UNIT_NEWTON',
-    UnitVolt: 'UNIT_VOLT',
-    UnitCelsius: 'UNIT_CELSIUS',
-    UnitNewtonMeter: 'UNIT_NEWTON_METER',
+export const TrajectoryPausedByUserKindEnum = {
+    PausedByUser: 'PAUSED_BY_USER'
+} as const;
+
+export type TrajectoryPausedByUserKindEnum = typeof TrajectoryPausedByUserKindEnum[keyof typeof TrajectoryPausedByUserKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface TrajectoryPausedOnIO
+ */
+export interface TrajectoryPausedOnIO {
+    /**
+     * 
+     * @type {string}
+     * @memberof TrajectoryPausedOnIO
+     */
+    'kind': TrajectoryPausedOnIOKindEnum;
+}
+
+export const TrajectoryPausedOnIOKindEnum = {
+    PausedOnIo: 'PAUSED_ON_IO'
+} as const;
+
+export type TrajectoryPausedOnIOKindEnum = typeof TrajectoryPausedOnIOKindEnum[keyof typeof TrajectoryPausedOnIOKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface TrajectoryRunning
+ */
+export interface TrajectoryRunning {
+    /**
+     * 
+     * @type {string}
+     * @memberof TrajectoryRunning
+     */
+    'kind': TrajectoryRunningKindEnum;
+    /**
+     * Remaining time in milliseconds (ms) to reach the end of the motion.
+     * @type {number}
+     * @memberof TrajectoryRunning
+     */
+    'time_to_end': number;
+}
+
+export const TrajectoryRunningKindEnum = {
+    Running: 'RUNNING'
+} as const;
+
+export type TrajectoryRunningKindEnum = typeof TrajectoryRunningKindEnum[keyof typeof TrajectoryRunningKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface TrajectoryWaitForIO
+ */
+export interface TrajectoryWaitForIO {
+    /**
+     * 
+     * @type {string}
+     * @memberof TrajectoryWaitForIO
+     */
+    'kind': TrajectoryWaitForIOKindEnum;
+}
+
+export const TrajectoryWaitForIOKindEnum = {
+    WaitForIo: 'WAIT_FOR_IO'
+} as const;
+
+export type TrajectoryWaitForIOKindEnum = typeof TrajectoryWaitForIOKindEnum[keyof typeof TrajectoryWaitForIOKindEnum];
+
+/**
+ * The unit of input/output value.
+ * @export
+ * @enum {string}
+ */
+
+export const UnitType = {
+    UnitNone: 'UNIT_NONE',
+    UnitKilogram: 'UNIT_KILOGRAM',
+    UnitAmpere: 'UNIT_AMPERE',
+    UnitKelvin: 'UNIT_KELVIN',
+    UnitHertz: 'UNIT_HERTZ',
+    UnitNewton: 'UNIT_NEWTON',
+    UnitVolt: 'UNIT_VOLT',
+    UnitCelsius: 'UNIT_CELSIUS',
+    UnitNewtonMeter: 'UNIT_NEWTON_METER',
     UnitMeter: 'UNIT_METER'
 } as const;
 
@@ -4522,6 +5339,12 @@ export interface ValidationError {
      * @memberof ValidationError
      */
     'type': string;
+    /**
+     * 
+     * @type {{ [key: string]: any; }}
+     * @memberof ValidationError
+     */
+    'input': { [key: string]: any; };
 }
 /**
  * @type ValidationErrorLocInner
@@ -4564,7 +5387,7 @@ export interface VirtualController {
      * @type {string}
      * @memberof VirtualController
      */
-    'position'?: string;
+    'initial_joint_position'?: string;
 }
 
 export const VirtualControllerKindEnum = {
@@ -4614,6 +5437,7 @@ export const VirtualControllerTypes = {
     FanucCrx20ial: 'fanuc-crx20ial',
     FanucCrx25ia: 'fanuc-crx25ia',
     FanucCrx30ia: 'fanuc-crx30ia',
+    FanucCrx5ia: 'fanuc-crx5ia',
     FanucLrMate200iD: 'fanuc-lr_mate_200iD',
     FanucLrMate200iD4S: 'fanuc-lr_mate_200iD4S',
     FanucLrMate200iD7L: 'fanuc-lr_mate_200iD7L',
@@ -4621,6 +5445,7 @@ export const VirtualControllerTypes = {
     FanucM10iD16S: 'fanuc-m10iD16S',
     FanucM20iD25: 'fanuc-m20iD25',
     FanucM20iD35: 'fanuc-m20iD35',
+    FanucM710iC20L: 'fanuc-m710iC20L',
     FanucM900iB280L: 'fanuc-m900iB280L',
     FanucM900iB360E: 'fanuc-m900iB360E',
     FanucR2000ic125l: 'fanuc-r2000ic125l',
@@ -4711,26 +5536,6 @@ export interface VirtualRobotConfiguration {
      */
     'content': string;
 }
-/**
- * 
- * @export
- * @interface WaitForIO
- */
-export interface WaitForIO {
-    /**
-     * 
-     * @type {string}
-     * @memberof WaitForIO
-     */
-    'kind': WaitForIOKindEnum;
-}
-
-export const WaitForIOKindEnum = {
-    WaitForIo: 'WAIT_FOR_IO'
-} as const;
-
-export type WaitForIOKindEnum = typeof WaitForIOKindEnum[keyof typeof WaitForIOKindEnum];
-
 /**
  * The value to compare with the current value of the input/output.
  * @export
@@ -4786,7 +5591,7 @@ export type YaskawaControllerKindEnum = typeof YaskawaControllerKindEnum[keyof t
 export const ApplicationApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
         /**
-         * Install a basic, containerized web application to the cell to control robots with a customized frontend.  Prerequisites: A Docker hub account or similar container registry account, with valid credentials.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The endpoint where the API is reachable from the container serving the Application. > - `BASE_PATH`: The root path of the deployed Application. It will be reachable via: http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell where the application is deployed. 
+         * Install a basic, containerized web application to the cell to control robots with a customized frontend.  Prerequisites: A Docker hub account or similar container registry account, with valid credentials.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The API endpoint accessible from within the application container. > - `NATS_BROKER`: The NATS broker endpoint accessible from within the application container. > - `BASE_PATH`: The application\'s root path, accessible at http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell hosting the deployed application. 
          * @summary Add Application
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {App} app 
@@ -5092,7 +5897,7 @@ export const ApplicationApiFp = function(configuration?: Configuration) {
     const localVarAxiosParamCreator = ApplicationApiAxiosParamCreator(configuration)
     return {
         /**
-         * Install a basic, containerized web application to the cell to control robots with a customized frontend.  Prerequisites: A Docker hub account or similar container registry account, with valid credentials.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The endpoint where the API is reachable from the container serving the Application. > - `BASE_PATH`: The root path of the deployed Application. It will be reachable via: http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell where the application is deployed. 
+         * Install a basic, containerized web application to the cell to control robots with a customized frontend.  Prerequisites: A Docker hub account or similar container registry account, with valid credentials.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The API endpoint accessible from within the application container. > - `NATS_BROKER`: The NATS broker endpoint accessible from within the application container. > - `BASE_PATH`: The application\'s root path, accessible at http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell hosting the deployed application. 
          * @summary Add Application
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {App} app 
@@ -5189,7 +5994,7 @@ export const ApplicationApiFactory = function (configuration?: Configuration, ba
     const localVarFp = ApplicationApiFp(configuration)
     return {
         /**
-         * Install a basic, containerized web application to the cell to control robots with a customized frontend.  Prerequisites: A Docker hub account or similar container registry account, with valid credentials.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The endpoint where the API is reachable from the container serving the Application. > - `BASE_PATH`: The root path of the deployed Application. It will be reachable via: http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell where the application is deployed. 
+         * Install a basic, containerized web application to the cell to control robots with a customized frontend.  Prerequisites: A Docker hub account or similar container registry account, with valid credentials.  After adding the application to the cell, open the application on the Wandelbots NOVA home screen.  Read [build your application](/docs/docs/development/) for more information.  <!-- theme: none --> > #### Predefined Environment Variables > - `NOVA_API`: The API endpoint accessible from within the application container. > - `NATS_BROKER`: The NATS broker endpoint accessible from within the application container. > - `BASE_PATH`: The application\'s root path, accessible at http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell hosting the deployed application. 
          * @summary Add Application
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {App} app 
@@ -5260,92 +6065,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));
+    }
+
+    /**
+     * 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}
+     * @memberof BUSInputsOutputsApi
+     */
+    public getBusIOState(cell: string, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).getBusIOState(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 endpoint where the API is reachable from the container serving the Application. > - `BASE_PATH`: The root path of the deployed Application. It will be reachable via: http://$host/$BASE_PATH > - `CELL_NAME`: The name of the cell where the application is deployed. 
-     * @summary Add Application
+     * 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 {App} app 
-     * @param {number} [completionTimeout] 
+     * @param {Array<string>} [ios] 
      * @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 getBusIOValues(cell: string, ios?: Array<string>, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).getBusIOValues(cell, ios, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Delete all GUI applications from the cell.
-     * @summary Clear Applications
+     * Get description of PROFINET 
+     * @summary Get PROFINET Description
      * @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
+     * @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 getProfinetDescription(cell: string, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).getProfinetDescription(cell, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Delete a GUI application from the cell.
-     * @summary Delete Application
+     * 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} [completionTimeout] 
+     * @param {number} [inputOffset] 
+     * @param {number} [outputOffset] 
      * @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 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));
     }
 
     /**
-     * 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
+     * List all BUS Input/Output descriptions. 
+     * @summary List Descriptions
      * @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
+     * @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 listBusIODescriptions(cell: string, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).listBusIODescriptions(cell, 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 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}
-     * @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 listProfinetIOs(cell: string, options?: RawAxiosRequestConfig) {
+        return BUSInputsOutputsApiFp(this.configuration).listProfinetIOs(cell, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Update the configuration of a GUI application in the cell.
-     * @summary Update Configuration
+     * 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 {string} app 
-     * @param {App} app2 
-     * @param {number} [completionTimeout] 
+     * @param {Array<IOValue>} iOValue 
      * @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 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));
     }
 }
 
@@ -6262,52 +8197,6 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
 
 
     
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState). 
-         * @summary Current Mode
-         * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} controller Unique identifier to address a controller in the cell.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getMode: async (cell: string, controller: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getMode', 'cell', cell)
-            // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getMode', 'controller', controller)
-            const localVarPath = `/cells/{cell}/controllers/{controller}/mode`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
-            const localVarHeaderParameter = {} as any;
-            const localVarQueryParameter = {} as any;
-
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration)
-
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration)
-
-
-    
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
@@ -6503,7 +8392,7 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
             };
         },
         /**
-         * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change. 
+         * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > `setDefaultMode` enables the robot controller to stay in control mode to keep the motors activated. > This allows for faster execution of sequential movements as no mode switches are required.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change. 
          * @summary Set Default Mode
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {string} controller Unique identifier to address a controller in the cell.
@@ -6607,15 +8496,16 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
             };
         },
         /**
-         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller. 
+         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.  The stream can be opened before the controller is registered. To register a controller, call [addRobotController](addRobotController).  While connecting, the stream sends initialization updates. Once the controller reaches `MODE_MONITOR`, it sends controller state updates. 
          * @summary Stream State
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {string} controller Unique identifier to address a controller in the cell.
          * @param {number} [responseRate] 
+         * @param {number} [addControllerTimeout] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        streamRobotControllerState: async (cell: string, controller: string, responseRate?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        streamRobotControllerState: async (cell: string, controller: string, responseRate?: number, addControllerTimeout?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
             assertParamExists('streamRobotControllerState', 'cell', cell)
             // verify required parameter 'controller' is not null or undefined
@@ -6646,6 +8536,10 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
                 localVarQueryParameter['response_rate'] = responseRate;
             }
 
+            if (addControllerTimeout !== undefined) {
+                localVarQueryParameter['add_controller_timeout'] = addControllerTimeout;
+            }
+
 
     
             setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -6812,20 +8706,6 @@ export const ControllerApiFp = function(configuration?: Configuration) {
             const localVarOperationServerBasePath = operationServerMap['ControllerApi.getCurrentRobotControllerState']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
-        /**
-         * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState). 
-         * @summary Current Mode
-         * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} controller Unique identifier to address a controller in the cell.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getMode(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GetModeResponse>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getMode(cell, controller, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ControllerApi.getMode']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
         /**
          * Get the configuration for a robot controller. 
          * @summary Robot Controller
@@ -6883,7 +8763,7 @@ export const ControllerApiFp = function(configuration?: Configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change. 
+         * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > `setDefaultMode` enables the robot controller to stay in control mode to keep the motors activated. > This allows for faster execution of sequential movements as no mode switches are required.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change. 
          * @summary Set Default Mode
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {string} controller Unique identifier to address a controller in the cell.
@@ -6913,16 +8793,17 @@ export const ControllerApiFp = function(configuration?: Configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller. 
+         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.  The stream can be opened before the controller is registered. To register a controller, call [addRobotController](addRobotController).  While connecting, the stream sends initialization updates. Once the controller reaches `MODE_MONITOR`, it sends controller state updates. 
          * @summary Stream State
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {string} controller Unique identifier to address a controller in the cell.
          * @param {number} [responseRate] 
+         * @param {number} [addControllerTimeout] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async streamRobotControllerState(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RobotControllerState>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.streamRobotControllerState(cell, controller, responseRate, options);
+        async streamRobotControllerState(cell: string, controller: string, responseRate?: number, addControllerTimeout?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RobotControllerState>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.streamRobotControllerState(cell, controller, responseRate, addControllerTimeout, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['ControllerApi.streamRobotControllerState']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -7023,17 +8904,6 @@ export const ControllerApiFactory = function (configuration?: Configuration, bas
         getCurrentRobotControllerState(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<RobotControllerState> {
             return localVarFp.getCurrentRobotControllerState(cell, controller, options).then((request) => request(axios, basePath));
         },
-        /**
-         * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState). 
-         * @summary Current Mode
-         * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} controller Unique identifier to address a controller in the cell.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getMode(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<GetModeResponse> {
-            return localVarFp.getMode(cell, controller, options).then((request) => request(axios, basePath));
-        },
         /**
          * Get the configuration for a robot controller. 
          * @summary Robot Controller
@@ -7079,7 +8949,7 @@ export const ControllerApiFactory = function (configuration?: Configuration, bas
             return localVarFp.listRobotControllers(cell, options).then((request) => request(axios, basePath));
         },
         /**
-         * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change. 
+         * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > `setDefaultMode` enables the robot controller to stay in control mode to keep the motors activated. > This allows for faster execution of sequential movements as no mode switches are required.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change. 
          * @summary Set Default Mode
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {string} controller Unique identifier to address a controller in the cell.
@@ -7103,16 +8973,17 @@ export const ControllerApiFactory = function (configuration?: Configuration, bas
             return localVarFp.streamFreeDrive(cell, controller, responseRate, options).then((request) => request(axios, basePath));
         },
         /**
-         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller. 
+         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.  The stream can be opened before the controller is registered. To register a controller, call [addRobotController](addRobotController).  While connecting, the stream sends initialization updates. Once the controller reaches `MODE_MONITOR`, it sends controller state updates. 
          * @summary Stream State
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {string} controller Unique identifier to address a controller in the cell.
          * @param {number} [responseRate] 
+         * @param {number} [addControllerTimeout] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        streamRobotControllerState(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig): AxiosPromise<RobotControllerState> {
-            return localVarFp.streamRobotControllerState(cell, controller, responseRate, options).then((request) => request(axios, basePath));
+        streamRobotControllerState(cell: string, controller: string, responseRate?: number, addControllerTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise<RobotControllerState> {
+            return localVarFp.streamRobotControllerState(cell, controller, responseRate, addControllerTimeout, options).then((request) => request(axios, basePath));
         },
         /**
          * Update the configuration of a robot controller.  Reconfigure certain options of a robot controller, or deploy a specific container image of a robot controller.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior. 
@@ -7219,19 +9090,6 @@ export class ControllerApi extends BaseAPI {
         return ControllerApiFp(this.configuration).getCurrentRobotControllerState(cell, controller, options).then((request) => request(this.axios, this.basePath));
     }
 
-    /**
-     * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState). 
-     * @summary Current Mode
-     * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {string} controller Unique identifier to address a controller in the cell.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof ControllerApi
-     */
-    public getMode(cell: string, controller: string, options?: RawAxiosRequestConfig) {
-        return ControllerApiFp(this.configuration).getMode(cell, controller, options).then((request) => request(this.axios, this.basePath));
-    }
-
     /**
      * Get the configuration for a robot controller. 
      * @summary Robot Controller
@@ -7285,7 +9143,7 @@ export class ControllerApi extends BaseAPI {
     }
 
     /**
-     * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change. 
+     * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > `setDefaultMode` enables the robot controller to stay in control mode to keep the motors activated. > This allows for faster execution of sequential movements as no mode switches are required.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change. 
      * @summary Set Default Mode
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
      * @param {string} controller Unique identifier to address a controller in the cell.
@@ -7313,17 +9171,18 @@ export class ControllerApi extends BaseAPI {
     }
 
     /**
-     * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller. 
+     * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.  The stream can be opened before the controller is registered. To register a controller, call [addRobotController](addRobotController).  While connecting, the stream sends initialization updates. Once the controller reaches `MODE_MONITOR`, it sends controller state updates. 
      * @summary Stream State
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
      * @param {string} controller Unique identifier to address a controller in the cell.
      * @param {number} [responseRate] 
+     * @param {number} [addControllerTimeout] 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ControllerApi
      */
-    public streamRobotControllerState(cell: string, controller: string, responseRate?: number, options?: RawAxiosRequestConfig) {
-        return ControllerApiFp(this.configuration).streamRobotControllerState(cell, controller, responseRate, options).then((request) => request(this.axios, this.basePath));
+    public streamRobotControllerState(cell: string, controller: string, responseRate?: number, addControllerTimeout?: number, options?: RawAxiosRequestConfig) {
+        return ControllerApiFp(this.configuration).streamRobotControllerState(cell, controller, responseRate, addControllerTimeout, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -8007,6 +9866,52 @@ export class JoggingApi extends BaseAPI {
  */
 export const KinematicsApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
+        /**
+         * Returns the TCP poses for a list of given joint positions. 
+         * @summary Forward kinematics
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {ForwardKinematicsRequest} [forwardKinematicsRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        forwardKinematics: async (cell: string, forwardKinematicsRequest?: ForwardKinematicsRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('forwardKinematics', 'cell', cell)
+            const localVarPath = `/cells/{cell}/kinematic/forward`
+                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication BasicAuth required
+            // http basic authentication required
+            setBasicAuthToObject(localVarRequestOptions, configuration)
+
+            // authentication BearerAuth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration)
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(forwardKinematicsRequest, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * Returns the reachable joint positions for a list of given poses. 
          * @summary Inverse kinematics
@@ -8063,6 +9968,20 @@ export const KinematicsApiAxiosParamCreator = function (configuration?: Configur
 export const KinematicsApiFp = function(configuration?: Configuration) {
     const localVarAxiosParamCreator = KinematicsApiAxiosParamCreator(configuration)
     return {
+        /**
+         * Returns the TCP poses for a list of given joint positions. 
+         * @summary Forward kinematics
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {ForwardKinematicsRequest} [forwardKinematicsRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async forwardKinematics(cell: string, forwardKinematicsRequest?: ForwardKinematicsRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ForwardKinematicsResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.forwardKinematics(cell, forwardKinematicsRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['KinematicsApi.forwardKinematics']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * Returns the reachable joint positions for a list of given poses. 
          * @summary Inverse kinematics
@@ -8087,6 +10006,17 @@ export const KinematicsApiFp = function(configuration?: Configuration) {
 export const KinematicsApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
     const localVarFp = KinematicsApiFp(configuration)
     return {
+        /**
+         * Returns the TCP poses for a list of given joint positions. 
+         * @summary Forward kinematics
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {ForwardKinematicsRequest} [forwardKinematicsRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        forwardKinematics(cell: string, forwardKinematicsRequest?: ForwardKinematicsRequest, options?: RawAxiosRequestConfig): AxiosPromise<ForwardKinematicsResponse> {
+            return localVarFp.forwardKinematics(cell, forwardKinematicsRequest, options).then((request) => request(axios, basePath));
+        },
         /**
          * Returns the reachable joint positions for a list of given poses. 
          * @summary Inverse kinematics
@@ -8108,6 +10038,19 @@ export const KinematicsApiFactory = function (configuration?: Configuration, bas
  * @extends {BaseAPI}
  */
 export class KinematicsApi extends BaseAPI {
+    /**
+     * Returns the TCP poses for a list of given joint positions. 
+     * @summary Forward kinematics
+     * @param {string} cell Unique identifier addressing a cell in all API calls. 
+     * @param {ForwardKinematicsRequest} [forwardKinematicsRequest] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof KinematicsApi
+     */
+    public forwardKinematics(cell: string, forwardKinematicsRequest?: ForwardKinematicsRequest, options?: RawAxiosRequestConfig) {
+        return KinematicsApiFp(this.configuration).forwardKinematics(cell, forwardKinematicsRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Returns the reachable joint positions for a list of given poses. 
      * @summary Inverse kinematics
@@ -10042,27 +11985,27 @@ export class StoreCollisionComponentsApi extends BaseAPI {
 
 
 /**
- * StoreCollisionScenesApi - axios parameter creator
+ * StoreCollisionSetupsApi - axios parameter creator
  * @export
  */
-export const StoreCollisionScenesApiAxiosParamCreator = function (configuration?: Configuration) {
+export const StoreCollisionSetupsApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
         /**
-         * Deletes the stored scene.  <!-- theme: danger --> > This will delete persistently stored data. 
-         * @summary Delete Scene
+         * Deletes the stored collision setup.  <!-- theme: danger --> > This will delete persistently stored data. 
+         * @summary Delete Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
+         * @param {string} setup Identifier of the collision setup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        deleteStoredCollisionScene: async (cell: string, scene: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        deleteStoredCollisionSetup: async (cell: string, setup: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('deleteStoredCollisionScene', 'cell', cell)
-            // verify required parameter 'scene' is not null or undefined
-            assertParamExists('deleteStoredCollisionScene', 'scene', scene)
-            const localVarPath = `/cells/{cell}/store/collision/scenes/{scene}`
+            assertParamExists('deleteStoredCollisionSetup', 'cell', cell)
+            // verify required parameter 'setup' is not null or undefined
+            assertParamExists('deleteStoredCollisionSetup', 'setup', setup)
+            const localVarPath = `/cells/{cell}/store/collision/setups/{setup}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"scene"}}`, encodeURIComponent(String(scene)));
+                .replace(`{${"setup"}}`, encodeURIComponent(String(setup)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -10094,21 +12037,21 @@ export const StoreCollisionScenesApiAxiosParamCreator = function (configuration?
             };
         },
         /**
-         * Returns the stored scene. 
-         * @summary Get Scene
+         * Returns the stored collision setup. 
+         * @summary Get Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
+         * @param {string} setup Identifier of the collision setup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getStoredCollisionScene: async (cell: string, scene: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        getStoredCollisionSetup: async (cell: string, setup: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getStoredCollisionScene', 'cell', cell)
-            // verify required parameter 'scene' is not null or undefined
-            assertParamExists('getStoredCollisionScene', 'scene', scene)
-            const localVarPath = `/cells/{cell}/store/collision/scenes/{scene}`
+            assertParamExists('getStoredCollisionSetup', 'cell', cell)
+            // verify required parameter 'setup' is not null or undefined
+            assertParamExists('getStoredCollisionSetup', 'setup', setup)
+            const localVarPath = `/cells/{cell}/store/collision/setups/{setup}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"scene"}}`, encodeURIComponent(String(scene)));
+                .replace(`{${"setup"}}`, encodeURIComponent(String(setup)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -10140,16 +12083,16 @@ export const StoreCollisionScenesApiAxiosParamCreator = function (configuration?
             };
         },
         /**
-         * Returns a list of stored scenes. 
-         * @summary List Scenes
+         * Returns a list of stored collision setups. 
+         * @summary List Collision Setups
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listStoredCollisionScenes: async (cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        listStoredCollisionSetups: async (cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('listStoredCollisionScenes', 'cell', cell)
-            const localVarPath = `/cells/{cell}/store/collision/scenes`
+            assertParamExists('listStoredCollisionSetups', 'cell', cell)
+            const localVarPath = `/cells/{cell}/store/collision/setups`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -10182,24 +12125,24 @@ export const StoreCollisionScenesApiAxiosParamCreator = function (configuration?
             };
         },
         /**
-         * Creates or replaces the stored collision scene.  The scene is assembled from components as defined in the request body.  <!-- theme: info --> > This endpoint allows indicating previously stored components. > Components used within the request will be copied into the new or updated scene.  An error is returned if an indicated component does not exist. 
-         * @summary Store Scene
+         * Stores collision setup.  If the collision setup does not exist, it will be created. If the collision setup exists, it will be updated. 
+         * @summary Store Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
-         * @param {CollisionSceneAssembly} collisionSceneAssembly 
+         * @param {string} setup Identifier of the collision setup
+         * @param {CollisionSetup} collisionSetup 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        storeCollisionScene: async (cell: string, scene: string, collisionSceneAssembly: CollisionSceneAssembly, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        storeCollisionSetup: async (cell: string, setup: string, collisionSetup: CollisionSetup, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('storeCollisionScene', 'cell', cell)
-            // verify required parameter 'scene' is not null or undefined
-            assertParamExists('storeCollisionScene', 'scene', scene)
-            // verify required parameter 'collisionSceneAssembly' is not null or undefined
-            assertParamExists('storeCollisionScene', 'collisionSceneAssembly', collisionSceneAssembly)
-            const localVarPath = `/cells/{cell}/store/collision/scenes/{scene}`
+            assertParamExists('storeCollisionSetup', 'cell', cell)
+            // verify required parameter 'setup' is not null or undefined
+            assertParamExists('storeCollisionSetup', 'setup', setup)
+            // verify required parameter 'collisionSetup' is not null or undefined
+            assertParamExists('storeCollisionSetup', 'collisionSetup', collisionSetup)
+            const localVarPath = `/cells/{cell}/store/collision/setups/{setup}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"scene"}}`, encodeURIComponent(String(scene)));
+                .replace(`{${"setup"}}`, encodeURIComponent(String(setup)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -10226,7 +12169,7 @@ export const StoreCollisionScenesApiAxiosParamCreator = function (configuration?
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-            localVarRequestOptions.data = serializeDataIfNeeded(collisionSceneAssembly, localVarRequestOptions, configuration)
+            localVarRequestOptions.data = serializeDataIfNeeded(collisionSetup, localVarRequestOptions, configuration)
 
             return {
                 url: toPathString(localVarUrlObj),
@@ -10237,182 +12180,182 @@ export const StoreCollisionScenesApiAxiosParamCreator = function (configuration?
 };
 
 /**
- * StoreCollisionScenesApi - functional programming interface
+ * StoreCollisionSetupsApi - functional programming interface
  * @export
  */
-export const StoreCollisionScenesApiFp = function(configuration?: Configuration) {
-    const localVarAxiosParamCreator = StoreCollisionScenesApiAxiosParamCreator(configuration)
+export const StoreCollisionSetupsApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = StoreCollisionSetupsApiAxiosParamCreator(configuration)
     return {
         /**
-         * Deletes the stored scene.  <!-- theme: danger --> > This will delete persistently stored data. 
-         * @summary Delete Scene
+         * Deletes the stored collision setup.  <!-- theme: danger --> > This will delete persistently stored data. 
+         * @summary Delete Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
+         * @param {string} setup Identifier of the collision setup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async deleteStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.deleteStoredCollisionScene(cell, scene, options);
+        async deleteStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.deleteStoredCollisionSetup(cell, setup, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['StoreCollisionScenesApi.deleteStoredCollisionScene']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['StoreCollisionSetupsApi.deleteStoredCollisionSetup']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Returns the stored scene. 
-         * @summary Get Scene
+         * Returns the stored collision setup. 
+         * @summary Get Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
+         * @param {string} setup Identifier of the collision setup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async getStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CollisionScene>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getStoredCollisionScene(cell, scene, options);
+        async getStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CollisionSetup>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getStoredCollisionSetup(cell, setup, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['StoreCollisionScenesApi.getStoredCollisionScene']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['StoreCollisionSetupsApi.getStoredCollisionSetup']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Returns a list of stored scenes. 
-         * @summary List Scenes
+         * Returns a list of stored collision setups. 
+         * @summary List Collision Setups
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async listStoredCollisionScenes(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{ [key: string]: CollisionScene; }>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listStoredCollisionScenes(cell, options);
+        async listStoredCollisionSetups(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{ [key: string]: CollisionSetup; }>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listStoredCollisionSetups(cell, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['StoreCollisionScenesApi.listStoredCollisionScenes']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['StoreCollisionSetupsApi.listStoredCollisionSetups']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Creates or replaces the stored collision scene.  The scene is assembled from components as defined in the request body.  <!-- theme: info --> > This endpoint allows indicating previously stored components. > Components used within the request will be copied into the new or updated scene.  An error is returned if an indicated component does not exist. 
-         * @summary Store Scene
+         * Stores collision setup.  If the collision setup does not exist, it will be created. If the collision setup exists, it will be updated. 
+         * @summary Store Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
-         * @param {CollisionSceneAssembly} collisionSceneAssembly 
+         * @param {string} setup Identifier of the collision setup
+         * @param {CollisionSetup} collisionSetup 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async storeCollisionScene(cell: string, scene: string, collisionSceneAssembly: CollisionSceneAssembly, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CollisionScene>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.storeCollisionScene(cell, scene, collisionSceneAssembly, options);
+        async storeCollisionSetup(cell: string, setup: string, collisionSetup: CollisionSetup, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CollisionSetup>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.storeCollisionSetup(cell, setup, collisionSetup, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['StoreCollisionScenesApi.storeCollisionScene']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['StoreCollisionSetupsApi.storeCollisionSetup']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     }
 };
 
 /**
- * StoreCollisionScenesApi - factory interface
+ * StoreCollisionSetupsApi - factory interface
  * @export
  */
-export const StoreCollisionScenesApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
-    const localVarFp = StoreCollisionScenesApiFp(configuration)
+export const StoreCollisionSetupsApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
+    const localVarFp = StoreCollisionSetupsApiFp(configuration)
     return {
         /**
-         * Deletes the stored scene.  <!-- theme: danger --> > This will delete persistently stored data. 
-         * @summary Delete Scene
+         * Deletes the stored collision setup.  <!-- theme: danger --> > This will delete persistently stored data. 
+         * @summary Delete Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
+         * @param {string} setup Identifier of the collision setup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        deleteStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
-            return localVarFp.deleteStoredCollisionScene(cell, scene, options).then((request) => request(axios, basePath));
+        deleteStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.deleteStoredCollisionSetup(cell, setup, options).then((request) => request(axios, basePath));
         },
         /**
-         * Returns the stored scene. 
-         * @summary Get Scene
+         * Returns the stored collision setup. 
+         * @summary Get Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
+         * @param {string} setup Identifier of the collision setup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig): AxiosPromise<CollisionScene> {
-            return localVarFp.getStoredCollisionScene(cell, scene, options).then((request) => request(axios, basePath));
+        getStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig): AxiosPromise<CollisionSetup> {
+            return localVarFp.getStoredCollisionSetup(cell, setup, options).then((request) => request(axios, basePath));
         },
         /**
-         * Returns a list of stored scenes. 
-         * @summary List Scenes
+         * Returns a list of stored collision setups. 
+         * @summary List Collision Setups
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listStoredCollisionScenes(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<{ [key: string]: CollisionScene; }> {
-            return localVarFp.listStoredCollisionScenes(cell, options).then((request) => request(axios, basePath));
+        listStoredCollisionSetups(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<{ [key: string]: CollisionSetup; }> {
+            return localVarFp.listStoredCollisionSetups(cell, options).then((request) => request(axios, basePath));
         },
         /**
-         * Creates or replaces the stored collision scene.  The scene is assembled from components as defined in the request body.  <!-- theme: info --> > This endpoint allows indicating previously stored components. > Components used within the request will be copied into the new or updated scene.  An error is returned if an indicated component does not exist. 
-         * @summary Store Scene
+         * Stores collision setup.  If the collision setup does not exist, it will be created. If the collision setup exists, it will be updated. 
+         * @summary Store Collision Setup
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} scene Unique identifier addressing a collision scene.
-         * @param {CollisionSceneAssembly} collisionSceneAssembly 
+         * @param {string} setup Identifier of the collision setup
+         * @param {CollisionSetup} collisionSetup 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        storeCollisionScene(cell: string, scene: string, collisionSceneAssembly: CollisionSceneAssembly, options?: RawAxiosRequestConfig): AxiosPromise<CollisionScene> {
-            return localVarFp.storeCollisionScene(cell, scene, collisionSceneAssembly, options).then((request) => request(axios, basePath));
+        storeCollisionSetup(cell: string, setup: string, collisionSetup: CollisionSetup, options?: RawAxiosRequestConfig): AxiosPromise<CollisionSetup> {
+            return localVarFp.storeCollisionSetup(cell, setup, collisionSetup, options).then((request) => request(axios, basePath));
         },
     };
 };
 
 /**
- * StoreCollisionScenesApi - object-oriented interface
+ * StoreCollisionSetupsApi - object-oriented interface
  * @export
- * @class StoreCollisionScenesApi
+ * @class StoreCollisionSetupsApi
  * @extends {BaseAPI}
  */
-export class StoreCollisionScenesApi extends BaseAPI {
+export class StoreCollisionSetupsApi extends BaseAPI {
     /**
-     * Deletes the stored scene.  <!-- theme: danger --> > This will delete persistently stored data. 
-     * @summary Delete Scene
+     * Deletes the stored collision setup.  <!-- theme: danger --> > This will delete persistently stored data. 
+     * @summary Delete Collision Setup
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {string} scene Unique identifier addressing a collision scene.
+     * @param {string} setup Identifier of the collision setup
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof StoreCollisionScenesApi
+     * @memberof StoreCollisionSetupsApi
      */
-    public deleteStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig) {
-        return StoreCollisionScenesApiFp(this.configuration).deleteStoredCollisionScene(cell, scene, options).then((request) => request(this.axios, this.basePath));
+    public deleteStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig) {
+        return StoreCollisionSetupsApiFp(this.configuration).deleteStoredCollisionSetup(cell, setup, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Returns the stored scene. 
-     * @summary Get Scene
+     * Returns the stored collision setup. 
+     * @summary Get Collision Setup
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {string} scene Unique identifier addressing a collision scene.
+     * @param {string} setup Identifier of the collision setup
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof StoreCollisionScenesApi
+     * @memberof StoreCollisionSetupsApi
      */
-    public getStoredCollisionScene(cell: string, scene: string, options?: RawAxiosRequestConfig) {
-        return StoreCollisionScenesApiFp(this.configuration).getStoredCollisionScene(cell, scene, options).then((request) => request(this.axios, this.basePath));
+    public getStoredCollisionSetup(cell: string, setup: string, options?: RawAxiosRequestConfig) {
+        return StoreCollisionSetupsApiFp(this.configuration).getStoredCollisionSetup(cell, setup, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Returns a list of stored scenes. 
-     * @summary List Scenes
+     * Returns a list of stored collision setups. 
+     * @summary List Collision Setups
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof StoreCollisionScenesApi
+     * @memberof StoreCollisionSetupsApi
      */
-    public listStoredCollisionScenes(cell: string, options?: RawAxiosRequestConfig) {
-        return StoreCollisionScenesApiFp(this.configuration).listStoredCollisionScenes(cell, options).then((request) => request(this.axios, this.basePath));
+    public listStoredCollisionSetups(cell: string, options?: RawAxiosRequestConfig) {
+        return StoreCollisionSetupsApiFp(this.configuration).listStoredCollisionSetups(cell, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Creates or replaces the stored collision scene.  The scene is assembled from components as defined in the request body.  <!-- theme: info --> > This endpoint allows indicating previously stored components. > Components used within the request will be copied into the new or updated scene.  An error is returned if an indicated component does not exist. 
-     * @summary Store Scene
+     * Stores collision setup.  If the collision setup does not exist, it will be created. If the collision setup exists, it will be updated. 
+     * @summary Store Collision Setup
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {string} scene Unique identifier addressing a collision scene.
-     * @param {CollisionSceneAssembly} collisionSceneAssembly 
+     * @param {string} setup Identifier of the collision setup
+     * @param {CollisionSetup} collisionSetup 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof StoreCollisionScenesApi
+     * @memberof StoreCollisionSetupsApi
      */
-    public storeCollisionScene(cell: string, scene: string, collisionSceneAssembly: CollisionSceneAssembly, options?: RawAxiosRequestConfig) {
-        return StoreCollisionScenesApiFp(this.configuration).storeCollisionScene(cell, scene, collisionSceneAssembly, options).then((request) => request(this.axios, this.basePath));
+    public storeCollisionSetup(cell: string, setup: string, collisionSetup: CollisionSetup, options?: RawAxiosRequestConfig) {
+        return StoreCollisionSetupsApiFp(this.configuration).storeCollisionSetup(cell, setup, collisionSetup, options).then((request) => request(this.axios, this.basePath));
     }
 }
 
@@ -10975,16 +12918,14 @@ export class StoreObjectApi extends BaseAPI {
 export const SystemApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
         /**
-         * Retrieves a configuration backup based on provided resource identifiers. 
+         * Retrieves a configuration backup based on provided resource identifiers. If an empty array of resources is provided, a backup for all resources will be retrieved. 
          * @summary Retrieve Configuration Backup
-         * @param {Array<string>} resources List of resource identifiers to included in the backup and restore operations.
+         * @param {Array<string>} [resources] List of resource identifiers to include in the retrieval.
          * @param {{ [key: string]: string; }} [metadata] Additional metadata to add to the backup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        backupConfiguration: async (resources: Array<string>, metadata?: { [key: string]: string; }, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            // verify required parameter 'resources' is not null or undefined
-            assertParamExists('backupConfiguration', 'resources', resources)
+        backupConfiguration: async (resources?: Array<string>, metadata?: { [key: string]: string; }, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             const localVarPath = `/system/configuration`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -11372,14 +13313,14 @@ export const SystemApiFp = function(configuration?: Configuration) {
     const localVarAxiosParamCreator = SystemApiAxiosParamCreator(configuration)
     return {
         /**
-         * Retrieves a configuration backup based on provided resource identifiers. 
+         * Retrieves a configuration backup based on provided resource identifiers. If an empty array of resources is provided, a backup for all resources will be retrieved. 
          * @summary Retrieve Configuration Backup
-         * @param {Array<string>} resources List of resource identifiers to included in the backup and restore operations.
+         * @param {Array<string>} [resources] List of resource identifiers to include in the retrieval.
          * @param {{ [key: string]: string; }} [metadata] Additional metadata to add to the backup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async backupConfiguration(resources: Array<string>, metadata?: { [key: string]: string; }, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<File>> {
+        async backupConfiguration(resources?: Array<string>, metadata?: { [key: string]: string; }, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<File>> {
             const localVarAxiosArgs = await localVarAxiosParamCreator.backupConfiguration(resources, metadata, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['SystemApi.backupConfiguration']?.[localVarOperationServerIndex]?.url;
@@ -11497,14 +13438,14 @@ export const SystemApiFactory = function (configuration?: Configuration, basePat
     const localVarFp = SystemApiFp(configuration)
     return {
         /**
-         * Retrieves a configuration backup based on provided resource identifiers. 
+         * Retrieves a configuration backup based on provided resource identifiers. If an empty array of resources is provided, a backup for all resources will be retrieved. 
          * @summary Retrieve Configuration Backup
-         * @param {Array<string>} resources List of resource identifiers to included in the backup and restore operations.
+         * @param {Array<string>} [resources] List of resource identifiers to include in the retrieval.
          * @param {{ [key: string]: string; }} [metadata] Additional metadata to add to the backup
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        backupConfiguration(resources: Array<string>, metadata?: { [key: string]: string; }, options?: RawAxiosRequestConfig): AxiosPromise<File> {
+        backupConfiguration(resources?: Array<string>, metadata?: { [key: string]: string; }, options?: RawAxiosRequestConfig): AxiosPromise<File> {
             return localVarFp.backupConfiguration(resources, metadata, options).then((request) => request(axios, basePath));
         },
         /**
@@ -11595,15 +13536,15 @@ export const SystemApiFactory = function (configuration?: Configuration, basePat
  */
 export class SystemApi extends BaseAPI {
     /**
-     * Retrieves a configuration backup based on provided resource identifiers. 
+     * Retrieves a configuration backup based on provided resource identifiers. If an empty array of resources is provided, a backup for all resources will be retrieved. 
      * @summary Retrieve Configuration Backup
-     * @param {Array<string>} resources List of resource identifiers to included in the backup and restore operations.
+     * @param {Array<string>} [resources] List of resource identifiers to include in the retrieval.
      * @param {{ [key: string]: string; }} [metadata] Additional metadata to add to the backup
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof SystemApi
      */
-    public backupConfiguration(resources: Array<string>, metadata?: { [key: string]: string; }, options?: RawAxiosRequestConfig) {
+    public backupConfiguration(resources?: Array<string>, metadata?: { [key: string]: string; }, options?: RawAxiosRequestConfig) {
         return SystemApiFp(this.configuration).backupConfiguration(resources, metadata, options).then((request) => request(this.axios, this.basePath));
     }
 
@@ -12324,7 +14265,53 @@ export class TrajectoryExecutionApi extends BaseAPI {
 export const TrajectoryPlanningApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
         /**
-         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion.
+         * Plans a collision-free trajectory for a single motion group using point-to-point (PTP) motions.  This endpoint is specifically designed for collision-free path planning algorithms that find a trajectory from a start joint position to a target position while avoiding obstacles.  Use the following workflow to execute a planned collision-free trajectory: 1. Plan a collision-free trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory planning fails due to collision or algorithm constraints, the response will contain error information about the failure. 
+         * @summary Plan Collision-Free Trajectory
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {PlanCollisionFreeRequest} [planCollisionFreeRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        planCollisionFree: async (cell: string, planCollisionFreeRequest?: PlanCollisionFreeRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('planCollisionFree', 'cell', cell)
+            const localVarPath = `/cells/{cell}/trajectory-planning/plan-collision-free`
+                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication BasicAuth required
+            // http basic authentication required
+            setBasicAuthToObject(localVarRequestOptions, configuration)
+
+            // authentication BearerAuth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration)
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(planCollisionFreeRequest, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion. 
          * @summary Plan Trajectory
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {PlanTrajectoryRequest} [planTrajectoryRequest] 
@@ -12380,7 +14367,21 @@ export const TrajectoryPlanningApiFp = function(configuration?: Configuration) {
     const localVarAxiosParamCreator = TrajectoryPlanningApiAxiosParamCreator(configuration)
     return {
         /**
-         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion.
+         * Plans a collision-free trajectory for a single motion group using point-to-point (PTP) motions.  This endpoint is specifically designed for collision-free path planning algorithms that find a trajectory from a start joint position to a target position while avoiding obstacles.  Use the following workflow to execute a planned collision-free trajectory: 1. Plan a collision-free trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory planning fails due to collision or algorithm constraints, the response will contain error information about the failure. 
+         * @summary Plan Collision-Free Trajectory
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {PlanCollisionFreeRequest} [planCollisionFreeRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async planCollisionFree(cell: string, planCollisionFreeRequest?: PlanCollisionFreeRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PlanCollisionFreeResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.planCollisionFree(cell, planCollisionFreeRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['TrajectoryPlanningApi.planCollisionFree']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion. 
          * @summary Plan Trajectory
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {PlanTrajectoryRequest} [planTrajectoryRequest] 
@@ -12404,7 +14405,18 @@ export const TrajectoryPlanningApiFactory = function (configuration?: Configurat
     const localVarFp = TrajectoryPlanningApiFp(configuration)
     return {
         /**
-         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion.
+         * Plans a collision-free trajectory for a single motion group using point-to-point (PTP) motions.  This endpoint is specifically designed for collision-free path planning algorithms that find a trajectory from a start joint position to a target position while avoiding obstacles.  Use the following workflow to execute a planned collision-free trajectory: 1. Plan a collision-free trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory planning fails due to collision or algorithm constraints, the response will contain error information about the failure. 
+         * @summary Plan Collision-Free Trajectory
+         * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {PlanCollisionFreeRequest} [planCollisionFreeRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        planCollisionFree(cell: string, planCollisionFreeRequest?: PlanCollisionFreeRequest, options?: RawAxiosRequestConfig): AxiosPromise<PlanCollisionFreeResponse> {
+            return localVarFp.planCollisionFree(cell, planCollisionFreeRequest, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion. 
          * @summary Plan Trajectory
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {PlanTrajectoryRequest} [planTrajectoryRequest] 
@@ -12425,7 +14437,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]