@wandelbots/nova-api 25.7.0-dev.2 → 25.7.0-dev.21

package/v2/api.js

@@ -21,7 +21,7 @@ export const AbbControllerKindEnum = {
     AbbController: 'AbbController'
 };
 /**
- * ## BEHAVIOR_AUTOMATIC This is the default behavior. The motion group instantly takes any commanded joint configuration as actual joint state. Configures the compliance of the virtual robot with the normal ControllerState cycle time. If set, the virtual robot will act like a physical one, e.g. with a cycle time of 8ms to respond to a new joint state command. ## BEHAVIOR_AUTOMATIC_NOT_COMPLY_WITH_CYCLETIME Configures the compliance of the virtual robot with the normal ControllerState cycle time. If set, the robot will respond as fast as possible, limited only by software execution speed. Because of that the execution of a movement requires less time than with BEHAVIOR_AUTOMATIC. ## BEHAVIOR_EXTERNAL_SOURCE The external client is the only source of actual joint state changes. This mode is used to enable third party software indicating the current joint state via [externalJointsStream](externalJointsStream).
+ * ## BEHAVIOR_AUTOMATIC This is the default behavior. The motion groups of the controller take commanded joint configuration as actual joint state. Configures the compliance of the virtual robot with the normal ControllerState cycle time. If set, the virtual robot will act like a physical one, e.g. with a cycle time of 8ms to respond to a new joint state command. ## BEHAVIOR_AUTOMATIC_NOT_COMPLY_WITH_CYCLETIME Configures the compliance of the virtual robot with the normal ControllerState cycle time. If set, the robot will respond as fast as possible, limited only by software execution speed. Because of that the execution of a movement requires less time than with BEHAVIOR_AUTOMATIC. ## BEHAVIOR_EXTERNAL_SOURCE The external client is the only source of actual joint state changes. This mode is used to enable third party software indicating the current joint state via [externalJointsStream](externalJointsStream).
  * @export
  * @enum {string}
  */
@@ -86,9 +86,6 @@ export const Direction = {
     DirectionForward: 'DIRECTION_FORWARD',
     DirectionBackward: 'DIRECTION_BACKWARD'
 };
-export const EndOfTrajectoryKindEnum = {
-    EndOfTrajectory: 'END_OF_TRAJECTORY'
-};
 export const FanucControllerKindEnum = {
     FanucController: 'FanucController'
 };
@@ -153,6 +150,21 @@ export const IntegerValueValueTypeEnum = {
 export const JoggingDetailsKindEnum = {
     Jogging: 'JOGGING'
 };
+export const JoggingPausedByUserKindEnum = {
+    PausedByUser: 'PAUSED_BY_USER'
+};
+export const JoggingPausedNearCollisionKindEnum = {
+    PausedNearCollision: 'PAUSED_NEAR_COLLISION'
+};
+export const JoggingPausedNearJointLimitKindEnum = {
+    PausedNearJointLimit: 'PAUSED_NEAR_JOINT_LIMIT'
+};
+export const JoggingPausedOnIOKindEnum = {
+    PausedOnIo: 'PAUSED_ON_IO'
+};
+export const JoggingRunningKindEnum = {
+    Running: 'RUNNING'
+};
 export const JointVelocityRequestMessageTypeEnum = {
     JointVelocityRequest: 'JointVelocityRequest'
 };
@@ -187,7 +199,7 @@ export const Manufacturer = {
     Yaskawa: 'yaskawa'
 };
 export const MovementErrorResponseKindEnum = {
-    Error: 'ERROR'
+    MotionError: 'MOTION_ERROR'
 };
 /**
  * The operating state.
@@ -275,21 +287,6 @@ export const PauseMovementRequestMessageTypeEnum = {
 export const PauseMovementResponseKindEnum = {
     PauseReceived: 'PAUSE_RECEIVED'
 };
-export const PausedByRequestKindEnum = {
-    PausedByUser: 'PAUSED_BY_USER'
-};
-export const PausedByUserKindEnum = {
-    PausedByUser: 'PAUSED_BY_USER'
-};
-export const PausedNearCollisionKindEnum = {
-    PausedNearCollision: 'PAUSED_NEAR_COLLISION'
-};
-export const PausedNearJointLimitKindEnum = {
-    PausedNearJointLimit: 'PAUSED_NEAR_JOINT_LIMIT'
-};
-export const PausedOnIOKindEnum = {
-    PausedOnIo: 'PAUSED_ON_IO'
-};
 export const PlaneShapeTypeEnum = {
     Plane: 'plane'
 };
@@ -326,12 +323,6 @@ export const RobotSystemMode = {
     RobotSystemModeControl: 'ROBOT_SYSTEM_MODE_CONTROL',
     RobotSystemModeFreeDrive: 'ROBOT_SYSTEM_MODE_FREE_DRIVE'
 };
-export const RunningKindEnum = {
-    Running: 'RUNNING'
-};
-export const Running1KindEnum = {
-    Running: 'RUNNING'
-};
 /**
  * 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
@@ -437,9 +428,24 @@ export const TrajectoryDataMessageTypeEnum = {
 export const TrajectoryDetailsKindEnum = {
     Trajectory: 'TRAJECTORY'
 };
+export const TrajectoryEndedKindEnum = {
+    EndOfTrajectory: 'END_OF_TRAJECTORY'
+};
 export const TrajectoryIdMessageTypeEnum = {
     TrajectoryId: 'TrajectoryId'
 };
+export const TrajectoryPausedByUserKindEnum = {
+    PausedByUser: 'PAUSED_BY_USER'
+};
+export const TrajectoryPausedOnIOKindEnum = {
+    PausedOnIo: 'PAUSED_ON_IO'
+};
+export const TrajectoryRunningKindEnum = {
+    Running: 'RUNNING'
+};
+export const TrajectoryWaitForIOKindEnum = {
+    WaitForIo: 'WAIT_FOR_IO'
+};
 /**
  * The unit of input/output value.
  * @export
@@ -577,9 +583,6 @@ export const VirtualControllerTypes = {
     YaskawaHc10dtp: 'yaskawa-hc10dtp',
     YaskawaHc20dtp: 'yaskawa-hc20dtp'
 };
-export const WaitForIOKindEnum = {
-    WaitForIo: 'WAIT_FOR_IO'
-};
 export const YaskawaControllerKindEnum = {
     YaskawaController: 'YaskawaController'
 };
@@ -1777,6 +1780,45 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Get description of a configured robot controller including a list of connected motion group identifiers. Use [getMotionGroupDescription](getMotionGroupDescription) to get more information about the motion group.
+         * @summary Description
+         * @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}
+         */
+        getControllerDescription: async (cell, controller, options = {}) => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('getControllerDescription', 'cell', cell);
+            // verify required parameter 'controller' is not null or undefined
+            assertParamExists('getControllerDescription', 'controller', controller);
+            const localVarPath = `/cells/{cell}/controllers/{controller}/description`
+                .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 = {};
+            const localVarQueryParameter = {};
+            // 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,
+            };
+        },
         /**
          * Request a coordinate system specification for a given identifier. Use parameter orientation_type to get the orientation part of the transformation offset of the coordinate system returned in the requested orientation notation. If parameter orientation_type is not set, the orientation part of the transformation offset of the coordinate system is returned in rotation vector notation.  The coordinate systems from the robot controller are loaded when the motion group associated with the coordinate system is activated. With deactivation of the motion group, the associated coordinate systems are removed from NOVA. The unique identifier of the coordinate systems from the robot controllers are suffixed with \"On\" + the unique identifier of the robot controller.
          * @summary Coordinate System
@@ -1942,18 +1984,18 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Receive the configuration for a virtual robot controller. Used to configure a virtual robot controller via [addRobotController](addRobotController).  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle, and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
-         * @summary Virtual Robot Configuration
+         * Receive data to configure a virtual robot controller based on another controller. This can be used to create a virtual clone of a specific physical robot.  When adding a virtual controller, use the Virtual configuration variant of [addRobotController](addRobotController) and pass the content string from this endpoint as the `json` field. Omit the `type` field that selects a preset configuration which is not required when providing a complete configuration.  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle, and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
+         * @summary Virtual Controller Configuration
          * @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}
          */
-        getVirtualRobotConfiguration: async (cell, controller, options = {}) => {
+        getVirtualControllerConfiguration: async (cell, controller, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getVirtualRobotConfiguration', 'cell', cell);
+            assertParamExists('getVirtualControllerConfiguration', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getVirtualRobotConfiguration', 'controller', controller);
+            assertParamExists('getVirtualControllerConfiguration', 'controller', controller);
             const localVarPath = `/cells/{cell}/controllers/{controller}/virtual-robot-configuration`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
@@ -2290,6 +2332,20 @@ export const ControllerApiFp = function (configuration) {
             const localVarOperationServerBasePath = operationServerMap['ControllerApi.deleteRobotController']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
+        /**
+         * Get description of a configured robot controller including a list of connected motion group identifiers. Use [getMotionGroupDescription](getMotionGroupDescription) to get more information about the motion group.
+         * @summary Description
+         * @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 getControllerDescription(cell, controller, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getControllerDescription(cell, controller, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['ControllerApi.getControllerDescription']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * Request a coordinate system specification for a given identifier. Use parameter orientation_type to get the orientation part of the transformation offset of the coordinate system returned in the requested orientation notation. If parameter orientation_type is not set, the orientation part of the transformation offset of the coordinate system is returned in rotation vector notation.  The coordinate systems from the robot controller are loaded when the motion group associated with the coordinate system is activated. With deactivation of the motion group, the associated coordinate systems are removed from NOVA. The unique identifier of the coordinate systems from the robot controllers are suffixed with \"On\" + the unique identifier of the robot controller.
          * @summary Coordinate System
@@ -2349,17 +2405,17 @@ export const ControllerApiFp = function (configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Receive the configuration for a virtual robot controller. Used to configure a virtual robot controller via [addRobotController](addRobotController).  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle, and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
-         * @summary Virtual Robot Configuration
+         * Receive data to configure a virtual robot controller based on another controller. This can be used to create a virtual clone of a specific physical robot.  When adding a virtual controller, use the Virtual configuration variant of [addRobotController](addRobotController) and pass the content string from this endpoint as the `json` field. Omit the `type` field that selects a preset configuration which is not required when providing a complete configuration.  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle, and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
+         * @summary Virtual Controller Configuration
          * @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 getVirtualRobotConfiguration(cell, controller, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getVirtualRobotConfiguration(cell, controller, options);
+        async getVirtualControllerConfiguration(cell, controller, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getVirtualControllerConfiguration(cell, controller, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ControllerApi.getVirtualRobotConfiguration']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['ControllerApi.getVirtualControllerConfiguration']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -2495,6 +2551,17 @@ export const ControllerApiFactory = function (configuration, basePath, axios) {
         deleteRobotController(cell, controller, completionTimeout, options) {
             return localVarFp.deleteRobotController(cell, controller, completionTimeout, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Get description of a configured robot controller including a list of connected motion group identifiers. Use [getMotionGroupDescription](getMotionGroupDescription) to get more information about the motion group.
+         * @summary Description
+         * @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}
+         */
+        getControllerDescription(cell, controller, options) {
+            return localVarFp.getControllerDescription(cell, controller, options).then((request) => request(axios, basePath));
+        },
         /**
          * Request a coordinate system specification for a given identifier. Use parameter orientation_type to get the orientation part of the transformation offset of the coordinate system returned in the requested orientation notation. If parameter orientation_type is not set, the orientation part of the transformation offset of the coordinate system is returned in rotation vector notation.  The coordinate systems from the robot controller are loaded when the motion group associated with the coordinate system is activated. With deactivation of the motion group, the associated coordinate systems are removed from NOVA. The unique identifier of the coordinate systems from the robot controllers are suffixed with \"On\" + the unique identifier of the robot controller.
          * @summary Coordinate System
@@ -2542,15 +2609,15 @@ export const ControllerApiFactory = function (configuration, basePath, axios) {
             return localVarFp.getRobotController(cell, controller, options).then((request) => request(axios, basePath));
         },
         /**
-         * Receive the configuration for a virtual robot controller. Used to configure a virtual robot controller via [addRobotController](addRobotController).  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle, and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
-         * @summary Virtual Robot Configuration
+         * Receive data to configure a virtual robot controller based on another controller. This can be used to create a virtual clone of a specific physical robot.  When adding a virtual controller, use the Virtual configuration variant of [addRobotController](addRobotController) and pass the content string from this endpoint as the `json` field. Omit the `type` field that selects a preset configuration which is not required when providing a complete configuration.  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle, and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
+         * @summary Virtual Controller Configuration
          * @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}
          */
-        getVirtualRobotConfiguration(cell, controller, options) {
-            return localVarFp.getVirtualRobotConfiguration(cell, controller, options).then((request) => request(axios, basePath));
+        getVirtualControllerConfiguration(cell, controller, options) {
+            return localVarFp.getVirtualControllerConfiguration(cell, controller, options).then((request) => request(axios, basePath));
         },
         /**
          * Lists all specifications of coordinate systems from robot controllers. Use parameter orientation_type to get the orientation part of the transformation offset of the coordinate system returned in the requested orientation notation. If parameter orientation_type is not set, the orientation part of the transformation offset of the coordinate system is returned in rotation vector notation.  The coordinate systems from the robot controller are loaded when the motion group associated with the coordinate system is activated. With deactivation of the motion group, the associated coordinate systems are removed from NOVA. The unique identifier of the coordinate systems from the robot controllers are suffixed with \"On\" + the unique identifier of the robot controller.
@@ -2670,6 +2737,18 @@ export class ControllerApi extends BaseAPI {
     deleteRobotController(cell, controller, completionTimeout, options) {
         return ControllerApiFp(this.configuration).deleteRobotController(cell, controller, completionTimeout, options).then((request) => request(this.axios, this.basePath));
     }
+    /**
+     * Get description of a configured robot controller including a list of connected motion group identifiers. Use [getMotionGroupDescription](getMotionGroupDescription) to get more information about the motion group.
+     * @summary Description
+     * @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
+     */
+    getControllerDescription(cell, controller, options) {
+        return ControllerApiFp(this.configuration).getControllerDescription(cell, controller, options).then((request) => request(this.axios, this.basePath));
+    }
     /**
      * Request a coordinate system specification for a given identifier. Use parameter orientation_type to get the orientation part of the transformation offset of the coordinate system returned in the requested orientation notation. If parameter orientation_type is not set, the orientation part of the transformation offset of the coordinate system is returned in rotation vector notation.  The coordinate systems from the robot controller are loaded when the motion group associated with the coordinate system is activated. With deactivation of the motion group, the associated coordinate systems are removed from NOVA. The unique identifier of the coordinate systems from the robot controllers are suffixed with \"On\" + the unique identifier of the robot controller.
      * @summary Coordinate System
@@ -2721,16 +2800,16 @@ export class ControllerApi extends BaseAPI {
         return ControllerApiFp(this.configuration).getRobotController(cell, controller, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Receive the configuration for a virtual robot controller. Used to configure a virtual robot controller via [addRobotController](addRobotController).  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle, and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
-     * @summary Virtual Robot Configuration
+     * Receive data to configure a virtual robot controller based on another controller. This can be used to create a virtual clone of a specific physical robot.  When adding a virtual controller, use the Virtual configuration variant of [addRobotController](addRobotController) and pass the content string from this endpoint as the `json` field. Omit the `type` field that selects a preset configuration which is not required when providing a complete configuration.  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle, and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
+     * @summary Virtual Controller Configuration
      * @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
      */
-    getVirtualRobotConfiguration(cell, controller, options) {
-        return ControllerApiFp(this.configuration).getVirtualRobotConfiguration(cell, controller, options).then((request) => request(this.axios, this.basePath));
+    getVirtualControllerConfiguration(cell, controller, options) {
+        return ControllerApiFp(this.configuration).getVirtualControllerConfiguration(cell, controller, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * Lists all specifications of coordinate systems from robot controllers. Use parameter orientation_type to get the orientation part of the transformation offset of the coordinate system returned in the requested orientation notation. If parameter orientation_type is not set, the orientation part of the transformation offset of the coordinate system is returned in rotation vector notation.  The coordinate systems from the robot controller are loaded when the motion group associated with the coordinate system is activated. With deactivation of the motion group, the associated coordinate systems are removed from NOVA. The unique identifier of the coordinate systems from the robot controllers are suffixed with \"On\" + the unique identifier of the robot controller.
@@ -3292,17 +3371,21 @@ export const JoggingApiAxiosParamCreator = function (configuration) {
          * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP (Tool Center Point). The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send InitializeJoggingRequest to configure the jogging.  Sets robot controller mode to control mode. Sets rate and coordinate system for the jogging response.  #### 2. Send JointVelocityRequest or TcpVelocityRequest to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with JointVelocityRequest or TcpVelocityRequest. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - InitializeJoggingResponse is sent to signal the success or failure of the InitializeJoggingRequest. - Jogging responses are streamed continuously after an InitializeJoggingRequest is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - JoggingErrorResponse with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the JoggingResponse, verify that the robot control is in the desired state, e.g. standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
          * @summary Execute Jogging
          * @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 {ExecuteJoggingRequest} executeJoggingRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        executeJogging: async (cell, executeJoggingRequest, options = {}) => {
+        executeJogging: async (cell, controller, executeJoggingRequest, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
             assertParamExists('executeJogging', 'cell', cell);
+            // verify required parameter 'controller' is not null or undefined
+            assertParamExists('executeJogging', 'controller', controller);
             // verify required parameter 'executeJoggingRequest' is not null or undefined
             assertParamExists('executeJogging', 'executeJoggingRequest', executeJoggingRequest);
-            const localVarPath = `/cells/{cell}/execution/jogging`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
+            const localVarPath = `/cells/{cell}/controllers/{controller}/execution/jogging`
+                .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;
@@ -3341,12 +3424,13 @@ export const JoggingApiFp = function (configuration) {
          * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP (Tool Center Point). The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send InitializeJoggingRequest to configure the jogging.  Sets robot controller mode to control mode. Sets rate and coordinate system for the jogging response.  #### 2. Send JointVelocityRequest or TcpVelocityRequest to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with JointVelocityRequest or TcpVelocityRequest. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - InitializeJoggingResponse is sent to signal the success or failure of the InitializeJoggingRequest. - Jogging responses are streamed continuously after an InitializeJoggingRequest is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - JoggingErrorResponse with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the JoggingResponse, verify that the robot control is in the desired state, e.g. standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
          * @summary Execute Jogging
          * @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 {ExecuteJoggingRequest} executeJoggingRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async executeJogging(cell, executeJoggingRequest, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.executeJogging(cell, executeJoggingRequest, options);
+        async executeJogging(cell, controller, executeJoggingRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.executeJogging(cell, controller, executeJoggingRequest, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['JoggingApi.executeJogging']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -3364,12 +3448,13 @@ export const JoggingApiFactory = function (configuration, basePath, axios) {
          * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP (Tool Center Point). The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send InitializeJoggingRequest to configure the jogging.  Sets robot controller mode to control mode. Sets rate and coordinate system for the jogging response.  #### 2. Send JointVelocityRequest or TcpVelocityRequest to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with JointVelocityRequest or TcpVelocityRequest. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - InitializeJoggingResponse is sent to signal the success or failure of the InitializeJoggingRequest. - Jogging responses are streamed continuously after an InitializeJoggingRequest is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - JoggingErrorResponse with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the JoggingResponse, verify that the robot control is in the desired state, e.g. standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
          * @summary Execute Jogging
          * @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 {ExecuteJoggingRequest} executeJoggingRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        executeJogging(cell, executeJoggingRequest, options) {
-            return localVarFp.executeJogging(cell, executeJoggingRequest, options).then((request) => request(axios, basePath));
+        executeJogging(cell, controller, executeJoggingRequest, options) {
+            return localVarFp.executeJogging(cell, controller, executeJoggingRequest, options).then((request) => request(axios, basePath));
         },
     };
 };
@@ -3384,13 +3469,14 @@ export class JoggingApi extends BaseAPI {
      * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP (Tool Center Point). The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send InitializeJoggingRequest to configure the jogging.  Sets robot controller mode to control mode. Sets rate and coordinate system for the jogging response.  #### 2. Send JointVelocityRequest or TcpVelocityRequest to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with JointVelocityRequest or TcpVelocityRequest. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - InitializeJoggingResponse is sent to signal the success or failure of the InitializeJoggingRequest. - Jogging responses are streamed continuously after an InitializeJoggingRequest is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - JoggingErrorResponse with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the JoggingResponse, verify that the robot control is in the desired state, e.g. standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops.
      * @summary Execute Jogging
      * @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 {ExecuteJoggingRequest} executeJoggingRequest
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof JoggingApi
      */
-    executeJogging(cell, executeJoggingRequest, options) {
-        return JoggingApiFp(this.configuration).executeJogging(cell, executeJoggingRequest, options).then((request) => request(this.axios, this.basePath));
+    executeJogging(cell, controller, executeJoggingRequest, options) {
+        return JoggingApiFp(this.configuration).executeJogging(cell, controller, executeJoggingRequest, options).then((request) => request(this.axios, this.basePath));
     }
 }
 /**
@@ -3802,18 +3888,22 @@ export const MotionGroupApiAxiosParamCreator = function (configuration) {
          * Returns the current state of the selected motion group including the current joint position, velocity, pose, and more.
          * @summary 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 {string} motionGroup The motion-group identifier.
          * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the responses should be converted. If not set, world coordinate system is used.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getCurrentMotionGroupState: async (cell, motionGroup, responseCoordinateSystem, options = {}) => {
+        getCurrentMotionGroupState: async (cell, controller, motionGroup, responseCoordinateSystem, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
             assertParamExists('getCurrentMotionGroupState', 'cell', cell);
+            // verify required parameter 'controller' is not null or undefined
+            assertParamExists('getCurrentMotionGroupState', 'controller', controller);
             // verify required parameter 'motionGroup' is not null or undefined
             assertParamExists('getCurrentMotionGroupState', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/state`
+            const localVarPath = `/cells/{cell}/controllers/{controller}/motion-groups/{motion-group}/state`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
+                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
                 .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -3845,17 +3935,21 @@ export const MotionGroupApiAxiosParamCreator = function (configuration) {
          * Get the set of parameters that describe the motion group and its configuration including safety zones, limits, etc. This data might change upon connection to the robot.
          * @summary Description
          * @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 {string} motionGroup The motion-group identifier.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getMotionGroupDescription: async (cell, motionGroup, options = {}) => {
+        getMotionGroupDescription: async (cell, controller, motionGroup, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
             assertParamExists('getMotionGroupDescription', 'cell', cell);
+            // verify required parameter 'controller' is not null or undefined
+            assertParamExists('getMotionGroupDescription', 'controller', controller);
             // verify required parameter 'motionGroup' is not null or undefined
             assertParamExists('getMotionGroupDescription', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/description`
+            const localVarPath = `/cells/{cell}/controllers/{controller}/motion-groups/{motion-group}/description`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
+                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
                 .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -3884,19 +3978,23 @@ export const MotionGroupApiAxiosParamCreator = function (configuration) {
          * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected.
          * @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 {string} motionGroup The motion-group identifier.
          * @param {number} [responseRate] Update rate for the response message in milliseconds (ms). Default is 200 ms. We recommend to use the step rate of the controller or a multiple of the step rate as NOVA updates the state in the controller\&#39;s step rate as well. Minimal response rate is the step rate of controller.
          * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default is the world coordinate system.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        streamMotionGroupState: async (cell, motionGroup, responseRate, responseCoordinateSystem, options = {}) => {
+        streamMotionGroupState: async (cell, controller, motionGroup, responseRate, responseCoordinateSystem, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
             assertParamExists('streamMotionGroupState', 'cell', cell);
+            // verify required parameter 'controller' is not null or undefined
+            assertParamExists('streamMotionGroupState', 'controller', controller);
             // verify required parameter 'motionGroup' is not null or undefined
             assertParamExists('streamMotionGroupState', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/state-stream`
+            const localVarPath = `/cells/{cell}/controllers/{controller}/motion-groups/{motion-group}/state-stream`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
+                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
                 .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -3940,13 +4038,14 @@ export const MotionGroupApiFp = function (configuration) {
          * Returns the current state of the selected motion group including the current joint position, velocity, pose, and more.
          * @summary 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 {string} motionGroup The motion-group identifier.
          * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the responses should be converted. If not set, world coordinate system is used.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options);
+        async getCurrentMotionGroupState(cell, controller, motionGroup, responseCoordinateSystem, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getCurrentMotionGroupState(cell, controller, motionGroup, responseCoordinateSystem, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['MotionGroupApi.getCurrentMotionGroupState']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -3955,12 +4054,13 @@ export const MotionGroupApiFp = function (configuration) {
          * Get the set of parameters that describe the motion group and its configuration including safety zones, limits, etc. This data might change upon connection to the robot.
          * @summary Description
          * @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 {string} motionGroup The motion-group identifier.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async getMotionGroupDescription(cell, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getMotionGroupDescription(cell, motionGroup, options);
+        async getMotionGroupDescription(cell, controller, motionGroup, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getMotionGroupDescription(cell, controller, motionGroup, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['MotionGroupApi.getMotionGroupDescription']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -3969,14 +4069,15 @@ export const MotionGroupApiFp = function (configuration) {
          * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected.
          * @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 {string} motionGroup The motion-group identifier.
          * @param {number} [responseRate] Update rate for the response message in milliseconds (ms). Default is 200 ms. We recommend to use the step rate of the controller or a multiple of the step rate as NOVA updates the state in the controller\&#39;s step rate as well. Minimal response rate is the step rate of controller.
          * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default is the world coordinate system.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options);
+        async streamMotionGroupState(cell, controller, motionGroup, responseRate, responseCoordinateSystem, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.streamMotionGroupState(cell, controller, motionGroup, responseRate, responseCoordinateSystem, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['MotionGroupApi.streamMotionGroupState']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -3994,37 +4095,40 @@ export const MotionGroupApiFactory = function (configuration, basePath, axios) {
          * Returns the current state of the selected motion group including the current joint position, velocity, pose, and more.
          * @summary 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 {string} motionGroup The motion-group identifier.
          * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the responses should be converted. If not set, world coordinate system is used.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options) {
-            return localVarFp.getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options).then((request) => request(axios, basePath));
+        getCurrentMotionGroupState(cell, controller, motionGroup, responseCoordinateSystem, options) {
+            return localVarFp.getCurrentMotionGroupState(cell, controller, motionGroup, responseCoordinateSystem, options).then((request) => request(axios, basePath));
         },
         /**
          * Get the set of parameters that describe the motion group and its configuration including safety zones, limits, etc. This data might change upon connection to the robot.
          * @summary Description
          * @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 {string} motionGroup The motion-group identifier.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getMotionGroupDescription(cell, motionGroup, options) {
-            return localVarFp.getMotionGroupDescription(cell, motionGroup, options).then((request) => request(axios, basePath));
+        getMotionGroupDescription(cell, controller, motionGroup, options) {
+            return localVarFp.getMotionGroupDescription(cell, controller, motionGroup, options).then((request) => request(axios, basePath));
         },
         /**
          * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected.
          * @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 {string} motionGroup The motion-group identifier.
          * @param {number} [responseRate] Update rate for the response message in milliseconds (ms). Default is 200 ms. We recommend to use the step rate of the controller or a multiple of the step rate as NOVA updates the state in the controller\&#39;s step rate as well. Minimal response rate is the step rate of controller.
          * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default is the world coordinate system.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options) {
-            return localVarFp.streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options).then((request) => request(axios, basePath));
+        streamMotionGroupState(cell, controller, motionGroup, responseRate, responseCoordinateSystem, options) {
+            return localVarFp.streamMotionGroupState(cell, controller, motionGroup, responseRate, responseCoordinateSystem, options).then((request) => request(axios, basePath));
         },
     };
 };
@@ -4039,31 +4143,34 @@ export class MotionGroupApi extends BaseAPI {
      * Returns the current state of the selected motion group including the current joint position, velocity, pose, and more.
      * @summary 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 {string} motionGroup The motion-group identifier.
      * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the responses should be converted. If not set, world coordinate system is used.
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof MotionGroupApi
      */
-    getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options) {
-        return MotionGroupApiFp(this.configuration).getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options).then((request) => request(this.axios, this.basePath));
+    getCurrentMotionGroupState(cell, controller, motionGroup, responseCoordinateSystem, options) {
+        return MotionGroupApiFp(this.configuration).getCurrentMotionGroupState(cell, controller, motionGroup, responseCoordinateSystem, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * Get the set of parameters that describe the motion group and its configuration including safety zones, limits, etc. This data might change upon connection to the robot.
      * @summary Description
      * @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 {string} motionGroup The motion-group identifier.
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof MotionGroupApi
      */
-    getMotionGroupDescription(cell, motionGroup, options) {
-        return MotionGroupApiFp(this.configuration).getMotionGroupDescription(cell, motionGroup, options).then((request) => request(this.axios, this.basePath));
+    getMotionGroupDescription(cell, controller, motionGroup, options) {
+        return MotionGroupApiFp(this.configuration).getMotionGroupDescription(cell, controller, motionGroup, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected.
      * @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 {string} motionGroup The motion-group identifier.
      * @param {number} [responseRate] Update rate for the response message in milliseconds (ms). Default is 200 ms. We recommend to use the step rate of the controller or a multiple of the step rate as NOVA updates the state in the controller\&#39;s step rate as well. Minimal response rate is the step rate of controller.
      * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default is the world coordinate system.
@@ -4071,8 +4178,8 @@ export class MotionGroupApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof MotionGroupApi
      */
-    streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options) {
-        return MotionGroupApiFp(this.configuration).streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options).then((request) => request(this.axios, this.basePath));
+    streamMotionGroupState(cell, controller, motionGroup, responseRate, responseCoordinateSystem, options) {
+        return MotionGroupApiFp(this.configuration).streamMotionGroupState(cell, controller, motionGroup, responseRate, responseCoordinateSystem, options).then((request) => request(this.axios, this.basePath));
     }
 }
 /**
@@ -6698,17 +6805,21 @@ export const TrajectoryCachingApiAxiosParamCreator = function (configuration) {
          * <!-- theme: info -->  > Using the trajectory cache is an optional performance optimization. It is not necessary to use the cache to execute trajectories.  Loads and validates the data of a trajectory into the execution cache, rendering the trajectory executable. The response contains the result of the validation of the trajectory.  Validation can lead to three different results: - Fully valid: The whole trajectory can be executed from start to end. The response will contain an unique identifier which is used to move the robot. - Partially valid: Only parts of the trajectory can be executed. The response will contain an unique identifier to move the robot   and information about the failure for the part that is not executable. - Invalid: The trajectory can not be executed. The response will tell you the reason of failure.  If the trajectory is at least partially valid, the parts of the trajectory that are valid can be executed using the [executeTrajectory](executeTrajectory) endpoint.  The workflow is as follows:   - Generate a trajectory with [planTrajectory](planTrajectory) or your own motion planner,   - Send the trajectory to this endpoint to validate it and get a unique identifier for it,   - The unique identifier will appear in the list of available trajectories, see [listTrajectories](listTrajectories) endpoint, if it is at least partially executable.   - Execute your trajectory using the [executeTrajectory](executeTrajectory) endpoint.
          * @summary Add Trajectory
          * @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 {AddTrajectoryRequest} addTrajectoryRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        addTrajectory: async (cell, addTrajectoryRequest, options = {}) => {
+        addTrajectory: async (cell, controller, addTrajectoryRequest, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
             assertParamExists('addTrajectory', 'cell', cell);
+            // verify required parameter 'controller' is not null or undefined
+            assertParamExists('addTrajectory', 'controller', controller);
             // verify required parameter 'addTrajectoryRequest' is not null or undefined
             assertParamExists('addTrajectory', 'addTrajectoryRequest', addTrajectoryRequest);
-            const localVarPath = `/cells/{cell}/trajectories`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
+            const localVarPath = `/cells/{cell}/controllers/{controller}/trajectories`
+                .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;
@@ -6738,14 +6849,18 @@ export const TrajectoryCachingApiAxiosParamCreator = function (configuration) {
          * Clear the trajectory cache.
          * @summary Clear Trajectories
          * @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}
          */
-        clearTrajectories: async (cell, options = {}) => {
+        clearTrajectories: async (cell, controller, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
             assertParamExists('clearTrajectories', 'cell', cell);
-            const localVarPath = `/cells/{cell}/trajectories`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
+            // verify required parameter 'controller' is not null or undefined
+            assertParamExists('clearTrajectories', 'controller', controller);
+            const localVarPath = `/cells/{cell}/controllers/{controller}/trajectories`
+                .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;
@@ -6773,17 +6888,21 @@ export const TrajectoryCachingApiAxiosParamCreator = function (configuration) {
          * Delete a previously created trajectory from cache. Use [listTrajectories](listTrajectories) to list all cached trajectories. Trajectories are removed automatically if the motion group or the corresponding controller is disconnected.
          * @summary Delete Trajectory
          * @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 {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        deleteTrajectory: async (cell, trajectory, options = {}) => {
+        deleteTrajectory: async (cell, controller, trajectory, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
             assertParamExists('deleteTrajectory', 'cell', cell);
+            // verify required parameter 'controller' is not null or undefined
+            assertParamExists('deleteTrajectory', 'controller', controller);
             // verify required parameter 'trajectory' is not null or undefined
             assertParamExists('deleteTrajectory', 'trajectory', trajectory);
-            const localVarPath = `/cells/{cell}/trajectories/{trajectory}`
+            const localVarPath = `/cells/{cell}/controllers/{controller}/trajectories/{trajectory}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
+                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
                 .replace(`{${"trajectory"}}`, encodeURIComponent(String(trajectory)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -6812,17 +6931,21 @@ export const TrajectoryCachingApiAxiosParamCreator = function (configuration) {
          * Get a previously created trajectory from cache. Use [listTrajectories](listTrajectories) to list all cached trajectories.
          * @summary Get Trajectory
          * @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 {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getTrajectory: async (cell, trajectory, options = {}) => {
+        getTrajectory: async (cell, controller, trajectory, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
             assertParamExists('getTrajectory', 'cell', cell);
+            // verify required parameter 'controller' is not null or undefined
+            assertParamExists('getTrajectory', 'controller', controller);
             // verify required parameter 'trajectory' is not null or undefined
             assertParamExists('getTrajectory', 'trajectory', trajectory);
-            const localVarPath = `/cells/{cell}/trajectories/{trajectory}`
+            const localVarPath = `/cells/{cell}/controllers/{controller}/trajectories/{trajectory}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
+                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
                 .replace(`{${"trajectory"}}`, encodeURIComponent(String(trajectory)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -6851,14 +6974,18 @@ export const TrajectoryCachingApiAxiosParamCreator = function (configuration) {
          * List currently cached trajectories. Use [addTrajectory](addTrajectory) to add a new trajectory. Adding trajectories is necessary to execute them. Trajectories are removed if the corresponding motion group or controller disconnects.
          * @summary List Trajectories
          * @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}
          */
-        listTrajectories: async (cell, options = {}) => {
+        listTrajectories: async (cell, controller, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
             assertParamExists('listTrajectories', 'cell', cell);
-            const localVarPath = `/cells/{cell}/trajectories`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
+            // verify required parameter 'controller' is not null or undefined
+            assertParamExists('listTrajectories', 'controller', controller);
+            const localVarPath = `/cells/{cell}/controllers/{controller}/trajectories`
+                .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;
@@ -6895,12 +7022,13 @@ export const TrajectoryCachingApiFp = function (configuration) {
          * <!-- theme: info -->  > Using the trajectory cache is an optional performance optimization. It is not necessary to use the cache to execute trajectories.  Loads and validates the data of a trajectory into the execution cache, rendering the trajectory executable. The response contains the result of the validation of the trajectory.  Validation can lead to three different results: - Fully valid: The whole trajectory can be executed from start to end. The response will contain an unique identifier which is used to move the robot. - Partially valid: Only parts of the trajectory can be executed. The response will contain an unique identifier to move the robot   and information about the failure for the part that is not executable. - Invalid: The trajectory can not be executed. The response will tell you the reason of failure.  If the trajectory is at least partially valid, the parts of the trajectory that are valid can be executed using the [executeTrajectory](executeTrajectory) endpoint.  The workflow is as follows:   - Generate a trajectory with [planTrajectory](planTrajectory) or your own motion planner,   - Send the trajectory to this endpoint to validate it and get a unique identifier for it,   - The unique identifier will appear in the list of available trajectories, see [listTrajectories](listTrajectories) endpoint, if it is at least partially executable.   - Execute your trajectory using the [executeTrajectory](executeTrajectory) endpoint.
          * @summary Add Trajectory
          * @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 {AddTrajectoryRequest} addTrajectoryRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async addTrajectory(cell, addTrajectoryRequest, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.addTrajectory(cell, addTrajectoryRequest, options);
+        async addTrajectory(cell, controller, addTrajectoryRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.addTrajectory(cell, controller, addTrajectoryRequest, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['TrajectoryCachingApi.addTrajectory']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -6909,11 +7037,12 @@ export const TrajectoryCachingApiFp = function (configuration) {
          * Clear the trajectory cache.
          * @summary Clear Trajectories
          * @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 clearTrajectories(cell, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.clearTrajectories(cell, options);
+        async clearTrajectories(cell, controller, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.clearTrajectories(cell, controller, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['TrajectoryCachingApi.clearTrajectories']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -6922,12 +7051,13 @@ export const TrajectoryCachingApiFp = function (configuration) {
          * Delete a previously created trajectory from cache. Use [listTrajectories](listTrajectories) to list all cached trajectories. Trajectories are removed automatically if the motion group or the corresponding controller is disconnected.
          * @summary Delete Trajectory
          * @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 {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async deleteTrajectory(cell, trajectory, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.deleteTrajectory(cell, trajectory, options);
+        async deleteTrajectory(cell, controller, trajectory, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.deleteTrajectory(cell, controller, trajectory, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['TrajectoryCachingApi.deleteTrajectory']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -6936,12 +7066,13 @@ export const TrajectoryCachingApiFp = function (configuration) {
          * Get a previously created trajectory from cache. Use [listTrajectories](listTrajectories) to list all cached trajectories.
          * @summary Get Trajectory
          * @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 {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async getTrajectory(cell, trajectory, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getTrajectory(cell, trajectory, options);
+        async getTrajectory(cell, controller, trajectory, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getTrajectory(cell, controller, trajectory, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['TrajectoryCachingApi.getTrajectory']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -6950,11 +7081,12 @@ export const TrajectoryCachingApiFp = function (configuration) {
          * List currently cached trajectories. Use [addTrajectory](addTrajectory) to add a new trajectory. Adding trajectories is necessary to execute them. Trajectories are removed if the corresponding motion group or controller disconnects.
          * @summary List Trajectories
          * @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 listTrajectories(cell, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listTrajectories(cell, options);
+        async listTrajectories(cell, controller, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listTrajectories(cell, controller, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['TrajectoryCachingApi.listTrajectories']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -6972,54 +7104,59 @@ export const TrajectoryCachingApiFactory = function (configuration, basePath, ax
          * <!-- theme: info -->  > Using the trajectory cache is an optional performance optimization. It is not necessary to use the cache to execute trajectories.  Loads and validates the data of a trajectory into the execution cache, rendering the trajectory executable. The response contains the result of the validation of the trajectory.  Validation can lead to three different results: - Fully valid: The whole trajectory can be executed from start to end. The response will contain an unique identifier which is used to move the robot. - Partially valid: Only parts of the trajectory can be executed. The response will contain an unique identifier to move the robot   and information about the failure for the part that is not executable. - Invalid: The trajectory can not be executed. The response will tell you the reason of failure.  If the trajectory is at least partially valid, the parts of the trajectory that are valid can be executed using the [executeTrajectory](executeTrajectory) endpoint.  The workflow is as follows:   - Generate a trajectory with [planTrajectory](planTrajectory) or your own motion planner,   - Send the trajectory to this endpoint to validate it and get a unique identifier for it,   - The unique identifier will appear in the list of available trajectories, see [listTrajectories](listTrajectories) endpoint, if it is at least partially executable.   - Execute your trajectory using the [executeTrajectory](executeTrajectory) endpoint.
          * @summary Add Trajectory
          * @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 {AddTrajectoryRequest} addTrajectoryRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        addTrajectory(cell, addTrajectoryRequest, options) {
-            return localVarFp.addTrajectory(cell, addTrajectoryRequest, options).then((request) => request(axios, basePath));
+        addTrajectory(cell, controller, addTrajectoryRequest, options) {
+            return localVarFp.addTrajectory(cell, controller, addTrajectoryRequest, options).then((request) => request(axios, basePath));
         },
         /**
          * Clear the trajectory cache.
          * @summary Clear Trajectories
          * @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}
          */
-        clearTrajectories(cell, options) {
-            return localVarFp.clearTrajectories(cell, options).then((request) => request(axios, basePath));
+        clearTrajectories(cell, controller, options) {
+            return localVarFp.clearTrajectories(cell, controller, options).then((request) => request(axios, basePath));
         },
         /**
          * Delete a previously created trajectory from cache. Use [listTrajectories](listTrajectories) to list all cached trajectories. Trajectories are removed automatically if the motion group or the corresponding controller is disconnected.
          * @summary Delete Trajectory
          * @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 {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        deleteTrajectory(cell, trajectory, options) {
-            return localVarFp.deleteTrajectory(cell, trajectory, options).then((request) => request(axios, basePath));
+        deleteTrajectory(cell, controller, trajectory, options) {
+            return localVarFp.deleteTrajectory(cell, controller, trajectory, options).then((request) => request(axios, basePath));
         },
         /**
          * Get a previously created trajectory from cache. Use [listTrajectories](listTrajectories) to list all cached trajectories.
          * @summary Get Trajectory
          * @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 {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getTrajectory(cell, trajectory, options) {
-            return localVarFp.getTrajectory(cell, trajectory, options).then((request) => request(axios, basePath));
+        getTrajectory(cell, controller, trajectory, options) {
+            return localVarFp.getTrajectory(cell, controller, trajectory, options).then((request) => request(axios, basePath));
         },
         /**
          * List currently cached trajectories. Use [addTrajectory](addTrajectory) to add a new trajectory. Adding trajectories is necessary to execute them. Trajectories are removed if the corresponding motion group or controller disconnects.
          * @summary List Trajectories
          * @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}
          */
-        listTrajectories(cell, options) {
-            return localVarFp.listTrajectories(cell, options).then((request) => request(axios, basePath));
+        listTrajectories(cell, controller, options) {
+            return localVarFp.listTrajectories(cell, controller, options).then((request) => request(axios, basePath));
         },
     };
 };
@@ -7034,59 +7171,64 @@ export class TrajectoryCachingApi extends BaseAPI {
      * <!-- theme: info -->  > Using the trajectory cache is an optional performance optimization. It is not necessary to use the cache to execute trajectories.  Loads and validates the data of a trajectory into the execution cache, rendering the trajectory executable. The response contains the result of the validation of the trajectory.  Validation can lead to three different results: - Fully valid: The whole trajectory can be executed from start to end. The response will contain an unique identifier which is used to move the robot. - Partially valid: Only parts of the trajectory can be executed. The response will contain an unique identifier to move the robot   and information about the failure for the part that is not executable. - Invalid: The trajectory can not be executed. The response will tell you the reason of failure.  If the trajectory is at least partially valid, the parts of the trajectory that are valid can be executed using the [executeTrajectory](executeTrajectory) endpoint.  The workflow is as follows:   - Generate a trajectory with [planTrajectory](planTrajectory) or your own motion planner,   - Send the trajectory to this endpoint to validate it and get a unique identifier for it,   - The unique identifier will appear in the list of available trajectories, see [listTrajectories](listTrajectories) endpoint, if it is at least partially executable.   - Execute your trajectory using the [executeTrajectory](executeTrajectory) endpoint.
      * @summary Add Trajectory
      * @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 {AddTrajectoryRequest} addTrajectoryRequest
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof TrajectoryCachingApi
      */
-    addTrajectory(cell, addTrajectoryRequest, options) {
-        return TrajectoryCachingApiFp(this.configuration).addTrajectory(cell, addTrajectoryRequest, options).then((request) => request(this.axios, this.basePath));
+    addTrajectory(cell, controller, addTrajectoryRequest, options) {
+        return TrajectoryCachingApiFp(this.configuration).addTrajectory(cell, controller, addTrajectoryRequest, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * Clear the trajectory cache.
      * @summary Clear Trajectories
      * @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 TrajectoryCachingApi
      */
-    clearTrajectories(cell, options) {
-        return TrajectoryCachingApiFp(this.configuration).clearTrajectories(cell, options).then((request) => request(this.axios, this.basePath));
+    clearTrajectories(cell, controller, options) {
+        return TrajectoryCachingApiFp(this.configuration).clearTrajectories(cell, controller, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * Delete a previously created trajectory from cache. Use [listTrajectories](listTrajectories) to list all cached trajectories. Trajectories are removed automatically if the motion group or the corresponding controller is disconnected.
      * @summary Delete Trajectory
      * @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 {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory.
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof TrajectoryCachingApi
      */
-    deleteTrajectory(cell, trajectory, options) {
-        return TrajectoryCachingApiFp(this.configuration).deleteTrajectory(cell, trajectory, options).then((request) => request(this.axios, this.basePath));
+    deleteTrajectory(cell, controller, trajectory, options) {
+        return TrajectoryCachingApiFp(this.configuration).deleteTrajectory(cell, controller, trajectory, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * Get a previously created trajectory from cache. Use [listTrajectories](listTrajectories) to list all cached trajectories.
      * @summary Get Trajectory
      * @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 {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory.
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof TrajectoryCachingApi
      */
-    getTrajectory(cell, trajectory, options) {
-        return TrajectoryCachingApiFp(this.configuration).getTrajectory(cell, trajectory, options).then((request) => request(this.axios, this.basePath));
+    getTrajectory(cell, controller, trajectory, options) {
+        return TrajectoryCachingApiFp(this.configuration).getTrajectory(cell, controller, trajectory, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * List currently cached trajectories. Use [addTrajectory](addTrajectory) to add a new trajectory. Adding trajectories is necessary to execute them. Trajectories are removed if the corresponding motion group or controller disconnects.
      * @summary List Trajectories
      * @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 TrajectoryCachingApi
      */
-    listTrajectories(cell, options) {
-        return TrajectoryCachingApiFp(this.configuration).listTrajectories(cell, options).then((request) => request(this.axios, this.basePath));
+    listTrajectories(cell, controller, options) {
+        return TrajectoryCachingApiFp(this.configuration).listTrajectories(cell, controller, options).then((request) => request(this.axios, this.basePath));
     }
 }
 /**
@@ -7099,17 +7241,21 @@ export const TrajectoryExecutionApiAxiosParamCreator = function (configuration)
          * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a previously planned trajectory. Enables the caller to attach input/output actions to the trajectory.  Understanding the concept of location:   The location or path parameter specifies the exact position along a trajectory.   The location is a scalar value that ranges from 0 to `n`,   where `n` denotes the number of motion commands, or trajectory segments, e.g. line, p2p, etc. See [planMotion](planMotion).   Each integer value of the location corresponds to one motion command, e.g. 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with InitializeMovementRequest. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send InitializeMovementRequest to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send StartMovementRequest to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send PauseMovementRequest before the movement has reached its end location. - Change the movement\'s velocity with PlaybackSpeedRequest after initializing the movement with InitializeMovementRequest.  ### Responses  - InitializeMovementResponse is sent to signal the success or failure of the InitializeMovementRequest. - Movement responses are streamed after a StartMovementRequest successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by InitializeMovementRequest. - Standstill reponse  is sent once the movement has finished or has come to a standstill due to a pause. - PauseMovementResponse is sent to signal the success of the PauseMovementRequest. It does not signal the end of the movement.   End of movement is signaled by Standstill reponse . - PlaybackSpeedResponse is sent to signal the success of the PlaybackSpeedRequest. - MovementError with error details is sent in case of an unexpected error, e.g. controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending PauseMovementRequest and StartMovementRequest. - Send PlaybackSpeedRequest before StartMovementRequest to reduce the velocity of the movement before it starts. - Send PlaybackSpeedRequest repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send PlaybackSpeedRequest with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending StartMovementRequest after the movement has finished.
          * @summary Execute Trajectory
          * @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 {ExecuteTrajectoryRequest} executeTrajectoryRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        executeTrajectory: async (cell, executeTrajectoryRequest, options = {}) => {
+        executeTrajectory: async (cell, controller, executeTrajectoryRequest, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
             assertParamExists('executeTrajectory', 'cell', cell);
+            // verify required parameter 'controller' is not null or undefined
+            assertParamExists('executeTrajectory', 'controller', controller);
             // verify required parameter 'executeTrajectoryRequest' is not null or undefined
             assertParamExists('executeTrajectory', 'executeTrajectoryRequest', executeTrajectoryRequest);
-            const localVarPath = `/cells/{cell}/execution/trajectory`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
+            const localVarPath = `/cells/{cell}/controllers/{controller}/execution/trajectory`
+                .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;
@@ -7148,12 +7294,13 @@ export const TrajectoryExecutionApiFp = function (configuration) {
          * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a previously planned trajectory. Enables the caller to attach input/output actions to the trajectory.  Understanding the concept of location:   The location or path parameter specifies the exact position along a trajectory.   The location is a scalar value that ranges from 0 to `n`,   where `n` denotes the number of motion commands, or trajectory segments, e.g. line, p2p, etc. See [planMotion](planMotion).   Each integer value of the location corresponds to one motion command, e.g. 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with InitializeMovementRequest. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send InitializeMovementRequest to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send StartMovementRequest to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send PauseMovementRequest before the movement has reached its end location. - Change the movement\'s velocity with PlaybackSpeedRequest after initializing the movement with InitializeMovementRequest.  ### Responses  - InitializeMovementResponse is sent to signal the success or failure of the InitializeMovementRequest. - Movement responses are streamed after a StartMovementRequest successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by InitializeMovementRequest. - Standstill reponse  is sent once the movement has finished or has come to a standstill due to a pause. - PauseMovementResponse is sent to signal the success of the PauseMovementRequest. It does not signal the end of the movement.   End of movement is signaled by Standstill reponse . - PlaybackSpeedResponse is sent to signal the success of the PlaybackSpeedRequest. - MovementError with error details is sent in case of an unexpected error, e.g. controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending PauseMovementRequest and StartMovementRequest. - Send PlaybackSpeedRequest before StartMovementRequest to reduce the velocity of the movement before it starts. - Send PlaybackSpeedRequest repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send PlaybackSpeedRequest with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending StartMovementRequest after the movement has finished.
          * @summary Execute Trajectory
          * @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 {ExecuteTrajectoryRequest} executeTrajectoryRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async executeTrajectory(cell, executeTrajectoryRequest, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.executeTrajectory(cell, executeTrajectoryRequest, options);
+        async executeTrajectory(cell, controller, executeTrajectoryRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.executeTrajectory(cell, controller, executeTrajectoryRequest, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['TrajectoryExecutionApi.executeTrajectory']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -7171,12 +7318,13 @@ export const TrajectoryExecutionApiFactory = function (configuration, basePath,
          * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a previously planned trajectory. Enables the caller to attach input/output actions to the trajectory.  Understanding the concept of location:   The location or path parameter specifies the exact position along a trajectory.   The location is a scalar value that ranges from 0 to `n`,   where `n` denotes the number of motion commands, or trajectory segments, e.g. line, p2p, etc. See [planMotion](planMotion).   Each integer value of the location corresponds to one motion command, e.g. 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with InitializeMovementRequest. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send InitializeMovementRequest to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send StartMovementRequest to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send PauseMovementRequest before the movement has reached its end location. - Change the movement\'s velocity with PlaybackSpeedRequest after initializing the movement with InitializeMovementRequest.  ### Responses  - InitializeMovementResponse is sent to signal the success or failure of the InitializeMovementRequest. - Movement responses are streamed after a StartMovementRequest successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by InitializeMovementRequest. - Standstill reponse  is sent once the movement has finished or has come to a standstill due to a pause. - PauseMovementResponse is sent to signal the success of the PauseMovementRequest. It does not signal the end of the movement.   End of movement is signaled by Standstill reponse . - PlaybackSpeedResponse is sent to signal the success of the PlaybackSpeedRequest. - MovementError with error details is sent in case of an unexpected error, e.g. controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending PauseMovementRequest and StartMovementRequest. - Send PlaybackSpeedRequest before StartMovementRequest to reduce the velocity of the movement before it starts. - Send PlaybackSpeedRequest repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send PlaybackSpeedRequest with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending StartMovementRequest after the movement has finished.
          * @summary Execute Trajectory
          * @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 {ExecuteTrajectoryRequest} executeTrajectoryRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        executeTrajectory(cell, executeTrajectoryRequest, options) {
-            return localVarFp.executeTrajectory(cell, executeTrajectoryRequest, options).then((request) => request(axios, basePath));
+        executeTrajectory(cell, controller, executeTrajectoryRequest, options) {
+            return localVarFp.executeTrajectory(cell, controller, executeTrajectoryRequest, options).then((request) => request(axios, basePath));
         },
     };
 };
@@ -7191,13 +7339,14 @@ export class TrajectoryExecutionApi extends BaseAPI {
      * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a previously planned trajectory. Enables the caller to attach input/output actions to the trajectory.  Understanding the concept of location:   The location or path parameter specifies the exact position along a trajectory.   The location is a scalar value that ranges from 0 to `n`,   where `n` denotes the number of motion commands, or trajectory segments, e.g. line, p2p, etc. See [planMotion](planMotion).   Each integer value of the location corresponds to one motion command, e.g. 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with InitializeMovementRequest. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send InitializeMovementRequest to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send StartMovementRequest to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send PauseMovementRequest before the movement has reached its end location. - Change the movement\'s velocity with PlaybackSpeedRequest after initializing the movement with InitializeMovementRequest.  ### Responses  - InitializeMovementResponse is sent to signal the success or failure of the InitializeMovementRequest. - Movement responses are streamed after a StartMovementRequest successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by InitializeMovementRequest. - Standstill reponse  is sent once the movement has finished or has come to a standstill due to a pause. - PauseMovementResponse is sent to signal the success of the PauseMovementRequest. It does not signal the end of the movement.   End of movement is signaled by Standstill reponse . - PlaybackSpeedResponse is sent to signal the success of the PlaybackSpeedRequest. - MovementError with error details is sent in case of an unexpected error, e.g. controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending PauseMovementRequest and StartMovementRequest. - Send PlaybackSpeedRequest before StartMovementRequest to reduce the velocity of the movement before it starts. - Send PlaybackSpeedRequest repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send PlaybackSpeedRequest with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending StartMovementRequest after the movement has finished.
      * @summary Execute Trajectory
      * @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 {ExecuteTrajectoryRequest} executeTrajectoryRequest
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof TrajectoryExecutionApi
      */
-    executeTrajectory(cell, executeTrajectoryRequest, options) {
-        return TrajectoryExecutionApiFp(this.configuration).executeTrajectory(cell, executeTrajectoryRequest, options).then((request) => request(this.axios, this.basePath));
+    executeTrajectory(cell, controller, executeTrajectoryRequest, options) {
+        return TrajectoryExecutionApiFp(this.configuration).executeTrajectory(cell, controller, executeTrajectoryRequest, options).then((request) => request(this.axios, this.basePath));
     }
 }
 /**
@@ -7310,38 +7459,41 @@ export class TrajectoryPlanningApi extends BaseAPI {
     }
 }
 /**
- * VirtualRobotApi - axios parameter creator
+ * VirtualControllerApi - axios parameter creator
  * @export
  */
-export const VirtualRobotApiAxiosParamCreator = function (configuration) {
+export const VirtualControllerApiAxiosParamCreator = function (configuration) {
     return {
         /**
-         * Get the current motion group state which provides values for the joints\' position, velocity and acceleration.
-         * @summary Get Motion Group State
+         * Adds a coordinate system to the robot controller.
+         * @summary Add Coordinate Systems
          * @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 {string} motionGroup The motion-group identifier.
+         * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
+         * @param {CoordinateSystemData} coordinateSystemData
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getMotionGroupState: async (cell, controller, motionGroup, options = {}) => {
+        addVirtualControllerCoordinateSystem: async (cell, controller, coordinateSystem, coordinateSystemData, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getMotionGroupState', 'cell', cell);
+            assertParamExists('addVirtualControllerCoordinateSystem', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getMotionGroupState', 'controller', controller);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('getMotionGroupState', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/motion-groups/{motion-group}`
+            assertParamExists('addVirtualControllerCoordinateSystem', 'controller', controller);
+            // verify required parameter 'coordinateSystem' is not null or undefined
+            assertParamExists('addVirtualControllerCoordinateSystem', 'coordinateSystem', coordinateSystem);
+            // verify required parameter 'coordinateSystemData' is not null or undefined
+            assertParamExists('addVirtualControllerCoordinateSystem', 'coordinateSystemData', coordinateSystemData);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/coordinate-systems/{coordinate-system}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
+                .replace(`{${"coordinate-system"}}`, encodeURIComponent(String(coordinateSystem)));
             // 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 localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -7350,37 +7502,50 @@ export const VirtualRobotApiAxiosParamCreator = function (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(coordinateSystemData, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
             };
         },
         /**
-         * Gets information on the motion group.
-         * @summary Motion Group Description
+         * Adds a new TCP or updates an existing TCP in the motion group.  The position and rotation values in the request body are defined within the flange’s coordinate system.  > **NOTE** > > Ensure the TCP\'s position is within the robot\'s reach. Refer to the robot’s documentation or data sheet for details like joint limits or reach.
+         * @summary Add TCP
          * @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 {string} motionGroup The motion-group identifier.
+         * @param {string} tcp The unique identifier of a TCP.
+         * @param {RobotTcpData} robotTcpData
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getMotionGroups: async (cell, controller, options = {}) => {
+        addVirtualControllerTcp: async (cell, controller, motionGroup, tcp, robotTcpData, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getMotionGroups', 'cell', cell);
+            assertParamExists('addVirtualControllerTcp', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getMotionGroups', 'controller', controller);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/motion-groups`
+            assertParamExists('addVirtualControllerTcp', 'controller', controller);
+            // verify required parameter 'motionGroup' is not null or undefined
+            assertParamExists('addVirtualControllerTcp', 'motionGroup', motionGroup);
+            // verify required parameter 'tcp' is not null or undefined
+            assertParamExists('addVirtualControllerTcp', 'tcp', tcp);
+            // verify required parameter 'robotTcpData' is not null or undefined
+            assertParamExists('addVirtualControllerTcp', 'robotTcpData', robotTcpData);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/motion-groups/{motion-group}/tcps/{tcp}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
+                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
+                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)))
+                .replace(`{${"tcp"}}`, encodeURIComponent(String(tcp)));
             // 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 localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -7389,40 +7554,44 @@ export const VirtualRobotApiAxiosParamCreator = function (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(robotTcpData, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
             };
         },
         /**
-         * Retrieves the current values of inputs/outputs of the virtual controller.  The identifiers of inputs/outputs must be provided in the request. Request all available input/output identifiers via [listVirtualRobotIODescriptions](listVirtualRobotIODescriptions).
-         * @summary Get Inputs/Outputs
+         * Deletes a coordinate system from the virtual controller. This will remove the coordinate system from the list of coordinate systems and remove all dependent coordinate systems which use the deleted coordinate system as reference.
+         * @summary Remove Coordinate System
          * @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 {Array<string>} ios
+         * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
+         * @param {boolean} [deleteDependent] If true, all dependent coordinate systems will be deleted as well.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listIOs: async (cell, controller, ios, options = {}) => {
+        deleteVirtualControllerCoordinateSystem: async (cell, controller, coordinateSystem, deleteDependent, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('listIOs', 'cell', cell);
+            assertParamExists('deleteVirtualControllerCoordinateSystem', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('listIOs', 'controller', controller);
-            // verify required parameter 'ios' is not null or undefined
-            assertParamExists('listIOs', 'ios', ios);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/ios`
+            assertParamExists('deleteVirtualControllerCoordinateSystem', 'controller', controller);
+            // verify required parameter 'coordinateSystem' is not null or undefined
+            assertParamExists('deleteVirtualControllerCoordinateSystem', 'coordinateSystem', coordinateSystem);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/coordinate-systems/{coordinate-system}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
+                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
+                .replace(`{${"coordinate-system"}}`, encodeURIComponent(String(coordinateSystem)));
             // 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 localVarRequestOptions = { method: 'DELETE', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -7431,8 +7600,8 @@ export const VirtualRobotApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (ios) {
-                localVarQueryParameter['ios'] = ios;
+            if (deleteDependent !== undefined) {
+                localVarQueryParameter['delete_dependent'] = deleteDependent;
             }
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
@@ -7443,32 +7612,36 @@ export const VirtualRobotApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Lists the input/output descriptions of the virtual robot controller.  The input/output descriptions contain information like name, type and unit. Available inputs/outputs are defined by the virtual robot controller. Each input/output has a unique identifier. If no identifiers are specified in the request, all available inputs/outputs are retrieved by this endpoint. Exception: When a filter (e.g., direction, value_type, group) is applied, only matching inputs/outputs are returned.
-         * @summary List Input/Output Descriptions
+         * Removes the TCP from the motion group. An unknown TCP is a valid input.
+         * @summary Remove TCP
          * @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 {Array<string>} [ios]
-         * @param {IODirection} [direction] Return only inputs/outputs with the specified direction.
-         * @param {IOValueType} [valueType] Return only inputs/outputs with the specified value type.
-         * @param {string} [group] Return only inputs/outputs from the specified group.
+         * @param {string} motionGroup The motion-group identifier.
+         * @param {string} tcp The unique identifier of a TCP.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listVirtualRobotIODescriptions: async (cell, controller, ios, direction, valueType, group, options = {}) => {
+        deleteVirtualControllerTcp: async (cell, controller, motionGroup, tcp, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('listVirtualRobotIODescriptions', 'cell', cell);
+            assertParamExists('deleteVirtualControllerTcp', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('listVirtualRobotIODescriptions', 'controller', controller);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/ios/description`
+            assertParamExists('deleteVirtualControllerTcp', 'controller', controller);
+            // verify required parameter 'motionGroup' is not null or undefined
+            assertParamExists('deleteVirtualControllerTcp', 'motionGroup', motionGroup);
+            // verify required parameter 'tcp' is not null or undefined
+            assertParamExists('deleteVirtualControllerTcp', 'tcp', tcp);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/motion-groups/{motion-group}/tcps/{tcp}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
+                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
+                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)))
+                .replace(`{${"tcp"}}`, encodeURIComponent(String(tcp)));
             // 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 localVarRequestOptions = { method: 'DELETE', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -7477,18 +7650,6 @@ export const VirtualRobotApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (ios) {
-                localVarQueryParameter['ios'] = ios;
-            }
-            if (direction !== undefined) {
-                localVarQueryParameter['direction'] = direction;
-            }
-            if (valueType !== undefined) {
-                localVarQueryParameter['value_type'] = valueType;
-            }
-            if (group !== undefined) {
-                localVarQueryParameter['group'] = group;
-            }
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -7498,22 +7659,19 @@ export const VirtualRobotApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Sets a list of values of a virtual controller inputs/outputs.
-         * @summary Set Input/Ouput Values
+         * Requests the Emergency Stop state of the virtual robot controller.  Use [getCurrentMotionGroupState](getCurrentMotionGroupState) to get the Emergency Stop state regardless of the controller type. There the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed when using virtual robot controllers.
+         * @summary Get Emergency Stop 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 {Array<IOValue>} iOValue
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        setIOValues: async (cell, controller, iOValue, options = {}) => {
+        getEmergencyStop: async (cell, controller, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('setIOValues', 'cell', cell);
+            assertParamExists('getEmergencyStop', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('setIOValues', 'controller', controller);
-            // verify required parameter 'iOValue' is not null or undefined
-            assertParamExists('setIOValues', 'iOValue', iOValue);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/ios`
+            assertParamExists('getEmergencyStop', 'controller', controller);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/emergency-stop`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -7522,7 +7680,7 @@ export const VirtualRobotApiAxiosParamCreator = function (configuration) {
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -7531,36 +7689,31 @@ export const VirtualRobotApiAxiosParamCreator = function (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 the values for joint position, joint velocity or joint acceleration of a motion group state. The values are immediately applied to the joints of the motion group. We recommend to only use the endpoint when the motion group is in monitor mode. In case the motion group is controlled, currently jogging or planning motions, the values are overridden by the controller or an error may occur.
-         * @summary Set Motion Group State
+         * Get the current motion group state which provides values for the joints\' position, velocity and acceleration.
+         * @summary Get Motion Group 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 {string} motionGroup The motion-group identifier.
-         * @param {MotionGroupJoints} motionGroupJoints
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        setMotionGroupState: async (cell, controller, motionGroup, motionGroupJoints, options = {}) => {
+        getMotionGroupState: async (cell, controller, motionGroup, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('setMotionGroupState', 'cell', cell);
+            assertParamExists('getMotionGroupState', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('setMotionGroupState', 'controller', controller);
+            assertParamExists('getMotionGroupState', 'controller', controller);
             // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('setMotionGroupState', 'motionGroup', motionGroup);
-            // verify required parameter 'motionGroupJoints' is not null or undefined
-            assertParamExists('setMotionGroupState', 'motionGroupJoints', motionGroupJoints);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/motion-groups/{motion-group}`
+            assertParamExists('getMotionGroupState', 'motionGroup', motionGroup);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/motion-groups/{motion-group}/state`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
                 .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
@@ -7570,7 +7723,7 @@ export const VirtualRobotApiAxiosParamCreator = function (configuration) {
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -7579,139 +7732,14 @@ export const VirtualRobotApiAxiosParamCreator = function (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(motionGroupJoints, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
             };
         },
-    };
-};
-/**
- * VirtualRobotApi - functional programming interface
- * @export
- */
-export const VirtualRobotApiFp = function (configuration) {
-    const localVarAxiosParamCreator = VirtualRobotApiAxiosParamCreator(configuration);
-    return {
-        /**
-         * Get the current motion group state which provides values for the joints\' position, velocity and acceleration.
-         * @summary Get Motion Group 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 {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getMotionGroupState(cell, controller, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getMotionGroupState(cell, controller, motionGroup, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotApi.getMotionGroupState']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Gets information on the motion group.
-         * @summary Motion Group Description
-         * @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 getMotionGroups(cell, controller, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getMotionGroups(cell, controller, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotApi.getMotionGroups']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Retrieves the current values of inputs/outputs of the virtual controller.  The identifiers of inputs/outputs must be provided in the request. Request all available input/output identifiers via [listVirtualRobotIODescriptions](listVirtualRobotIODescriptions).
-         * @summary Get Inputs/Outputs
-         * @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 {Array<string>} ios
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async listIOs(cell, controller, ios, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listIOs(cell, controller, ios, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotApi.listIOs']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Lists the input/output descriptions of the virtual robot controller.  The input/output descriptions contain information like name, type and unit. Available inputs/outputs are defined by the virtual robot controller. Each input/output has a unique identifier. If no identifiers are specified in the request, all available inputs/outputs are retrieved by this endpoint. Exception: When a filter (e.g., direction, value_type, group) is applied, only matching inputs/outputs are returned.
-         * @summary List Input/Output Descriptions
-         * @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 {Array<string>} [ios]
-         * @param {IODirection} [direction] Return only inputs/outputs with the specified direction.
-         * @param {IOValueType} [valueType] Return only inputs/outputs with the specified value type.
-         * @param {string} [group] Return only inputs/outputs from the specified group.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async listVirtualRobotIODescriptions(cell, controller, ios, direction, valueType, group, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listVirtualRobotIODescriptions(cell, controller, ios, direction, valueType, group, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotApi.listVirtualRobotIODescriptions']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Sets a list of values of a virtual controller inputs/outputs.
-         * @summary Set Input/Ouput Values
-         * @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 {Array<IOValue>} iOValue
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async setIOValues(cell, controller, iOValue, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.setIOValues(cell, controller, iOValue, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotApi.setIOValues']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Sets the values for joint position, joint velocity or joint acceleration of a motion group state. The values are immediately applied to the joints of the motion group. We recommend to only use the endpoint when the motion group is in monitor mode. In case the motion group is controlled, currently jogging or planning motions, the values are overridden by the controller or an error may occur.
-         * @summary Set Motion Group 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 {string} motionGroup The motion-group identifier.
-         * @param {MotionGroupJoints} motionGroupJoints
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async setMotionGroupState(cell, controller, motionGroup, motionGroupJoints, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.setMotionGroupState(cell, controller, motionGroup, motionGroupJoints, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotApi.setMotionGroupState']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-    };
-};
-/**
- * VirtualRobotApi - factory interface
- * @export
- */
-export const VirtualRobotApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = VirtualRobotApiFp(configuration);
-    return {
-        /**
-         * Get the current motion group state which provides values for the joints\' position, velocity and acceleration.
-         * @summary Get Motion Group 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 {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getMotionGroupState(cell, controller, motionGroup, options) {
-            return localVarFp.getMotionGroupState(cell, controller, motionGroup, options).then((request) => request(axios, basePath));
-        },
         /**
          * Gets information on the motion group.
          * @summary Motion Group Description
@@ -7720,175 +7748,12 @@ export const VirtualRobotApiFactory = function (configuration, basePath, axios)
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getMotionGroups(cell, controller, options) {
-            return localVarFp.getMotionGroups(cell, controller, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Retrieves the current values of inputs/outputs of the virtual controller.  The identifiers of inputs/outputs must be provided in the request. Request all available input/output identifiers via [listVirtualRobotIODescriptions](listVirtualRobotIODescriptions).
-         * @summary Get Inputs/Outputs
-         * @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 {Array<string>} ios
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        listIOs(cell, controller, ios, options) {
-            return localVarFp.listIOs(cell, controller, ios, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Lists the input/output descriptions of the virtual robot controller.  The input/output descriptions contain information like name, type and unit. Available inputs/outputs are defined by the virtual robot controller. Each input/output has a unique identifier. If no identifiers are specified in the request, all available inputs/outputs are retrieved by this endpoint. Exception: When a filter (e.g., direction, value_type, group) is applied, only matching inputs/outputs are returned.
-         * @summary List Input/Output Descriptions
-         * @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 {Array<string>} [ios]
-         * @param {IODirection} [direction] Return only inputs/outputs with the specified direction.
-         * @param {IOValueType} [valueType] Return only inputs/outputs with the specified value type.
-         * @param {string} [group] Return only inputs/outputs from the specified group.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        listVirtualRobotIODescriptions(cell, controller, ios, direction, valueType, group, options) {
-            return localVarFp.listVirtualRobotIODescriptions(cell, controller, ios, direction, valueType, group, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Sets a list of values of a virtual controller inputs/outputs.
-         * @summary Set Input/Ouput Values
-         * @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 {Array<IOValue>} iOValue
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        setIOValues(cell, controller, iOValue, options) {
-            return localVarFp.setIOValues(cell, controller, iOValue, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Sets the values for joint position, joint velocity or joint acceleration of a motion group state. The values are immediately applied to the joints of the motion group. We recommend to only use the endpoint when the motion group is in monitor mode. In case the motion group is controlled, currently jogging or planning motions, the values are overridden by the controller or an error may occur.
-         * @summary Set Motion Group 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 {string} motionGroup The motion-group identifier.
-         * @param {MotionGroupJoints} motionGroupJoints
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        setMotionGroupState(cell, controller, motionGroup, motionGroupJoints, options) {
-            return localVarFp.setMotionGroupState(cell, controller, motionGroup, motionGroupJoints, options).then((request) => request(axios, basePath));
-        },
-    };
-};
-/**
- * VirtualRobotApi - object-oriented interface
- * @export
- * @class VirtualRobotApi
- * @extends {BaseAPI}
- */
-export class VirtualRobotApi extends BaseAPI {
-    /**
-     * Get the current motion group state which provides values for the joints\' position, velocity and acceleration.
-     * @summary Get Motion Group 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 {string} motionGroup The motion-group identifier.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof VirtualRobotApi
-     */
-    getMotionGroupState(cell, controller, motionGroup, options) {
-        return VirtualRobotApiFp(this.configuration).getMotionGroupState(cell, controller, motionGroup, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Gets information on the motion group.
-     * @summary Motion Group Description
-     * @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 VirtualRobotApi
-     */
-    getMotionGroups(cell, controller, options) {
-        return VirtualRobotApiFp(this.configuration).getMotionGroups(cell, controller, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Retrieves the current values of inputs/outputs of the virtual controller.  The identifiers of inputs/outputs must be provided in the request. Request all available input/output identifiers via [listVirtualRobotIODescriptions](listVirtualRobotIODescriptions).
-     * @summary Get Inputs/Outputs
-     * @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 {Array<string>} ios
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof VirtualRobotApi
-     */
-    listIOs(cell, controller, ios, options) {
-        return VirtualRobotApiFp(this.configuration).listIOs(cell, controller, ios, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Lists the input/output descriptions of the virtual robot controller.  The input/output descriptions contain information like name, type and unit. Available inputs/outputs are defined by the virtual robot controller. Each input/output has a unique identifier. If no identifiers are specified in the request, all available inputs/outputs are retrieved by this endpoint. Exception: When a filter (e.g., direction, value_type, group) is applied, only matching inputs/outputs are returned.
-     * @summary List Input/Output Descriptions
-     * @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 {Array<string>} [ios]
-     * @param {IODirection} [direction] Return only inputs/outputs with the specified direction.
-     * @param {IOValueType} [valueType] Return only inputs/outputs with the specified value type.
-     * @param {string} [group] Return only inputs/outputs from the specified group.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof VirtualRobotApi
-     */
-    listVirtualRobotIODescriptions(cell, controller, ios, direction, valueType, group, options) {
-        return VirtualRobotApiFp(this.configuration).listVirtualRobotIODescriptions(cell, controller, ios, direction, valueType, group, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Sets a list of values of a virtual controller inputs/outputs.
-     * @summary Set Input/Ouput Values
-     * @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 {Array<IOValue>} iOValue
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof VirtualRobotApi
-     */
-    setIOValues(cell, controller, iOValue, options) {
-        return VirtualRobotApiFp(this.configuration).setIOValues(cell, controller, iOValue, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Sets the values for joint position, joint velocity or joint acceleration of a motion group state. The values are immediately applied to the joints of the motion group. We recommend to only use the endpoint when the motion group is in monitor mode. In case the motion group is controlled, currently jogging or planning motions, the values are overridden by the controller or an error may occur.
-     * @summary Set Motion Group 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 {string} motionGroup The motion-group identifier.
-     * @param {MotionGroupJoints} motionGroupJoints
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof VirtualRobotApi
-     */
-    setMotionGroupState(cell, controller, motionGroup, motionGroupJoints, options) {
-        return VirtualRobotApiFp(this.configuration).setMotionGroupState(cell, controller, motionGroup, motionGroupJoints, options).then((request) => request(this.axios, this.basePath));
-    }
-}
-/**
- * VirtualRobotBehaviorApi - axios parameter creator
- * @export
- */
-export const VirtualRobotBehaviorApiAxiosParamCreator = function (configuration) {
-    return {
-        /**
-         * <!-- theme: danger -->  > Websocket endpoint  This stream provides the commanded joint state and sets a motion groups joint configuration, e.g. to move a motion group. The concept is that an application is using the Motion Service to move a motion group. The Motion Service is commanding the desired joint configuration of a motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! It is __not__ providing the *actual* joint state! (Please file a request - if you need a stream of the *actual* joint state)  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configurations. CAUTION: Incoming joint configurations are not visualized and their velocity limits are not checked. we don\'t even check limits!  Possible use cases are: 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion group.  The stream only sends data to the robot controller if a motion is executed.  If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity.  2. Mimic Freedrive motions.  <!-- theme: danger -->  > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits.
-         * @summary Stream Joint Configuration
-         * @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 {ExternalJointStreamDatapoint} externalJointStreamDatapoint
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        externalJointsStream: async (cell, controller, externalJointStreamDatapoint, options = {}) => {
+        getMotionGroups: async (cell, controller, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('externalJointsStream', 'cell', cell);
+            assertParamExists('getMotionGroups', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('externalJointsStream', 'controller', controller);
-            // verify required parameter 'externalJointStreamDatapoint' is not null or undefined
-            assertParamExists('externalJointsStream', 'externalJointStreamDatapoint', externalJointStreamDatapoint);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/motion-groups/external-joints-stream`
+            assertParamExists('getMotionGroups', 'controller', controller);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/motion-groups`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -7906,51 +7771,6 @@ export const VirtualRobotBehaviorApiAxiosParamCreator = function (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(externalJointStreamDatapoint, localVarRequestOptions, configuration);
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Get the current robot motion group behavior - please see the setter [setMotionGroupBehavior](setMotionGroupBehavior) and the enum for details.
-         * @summary Behavior
-         * @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 {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getMotionGroupBehavior: async (cell, controller, motionGroup, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getMotionGroupBehavior', 'cell', cell);
-            // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getMotionGroupBehavior', 'controller', controller);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('getMotionGroupBehavior', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/motion-groups/{motion-group}/behavior`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // 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 = {};
-            const localVarQueryParameter = {};
-            // 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 };
@@ -7960,225 +7780,64 @@ export const VirtualRobotBehaviorApiAxiosParamCreator = function (configuration)
             };
         },
         /**
-         * Switch robot motion group behavior.
-         * @summary Switch Behavior
+         * Requests the Operation Mode of the virtual robot controller.  To get the Operation Mode regardless of the controller type use [getCurrentMotionGroupState](getCurrentMotionGroupState).  **Note:** The Operating Mode can only change be changed via API when using virtual robot controllers.
+         * @summary Get Operation 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 {string} motionGroup The motion-group identifier.
-         * @param {Behavior} [behavior]
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        setMotionGroupBehavior: async (cell, controller, motionGroup, behavior, options = {}) => {
+        getOperationMode: async (cell, controller, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('setMotionGroupBehavior', 'cell', cell);
-            // verify required parameter 'controller' is not null or undefined
-            assertParamExists('setMotionGroupBehavior', 'controller', controller);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('setMotionGroupBehavior', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/motion-groups/{motion-group}/behavior`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // 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 = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (behavior !== undefined) {
-                localVarQueryParameter['behavior'] = behavior;
-            }
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-    };
-};
-/**
- * VirtualRobotBehaviorApi - functional programming interface
- * @export
- */
-export const VirtualRobotBehaviorApiFp = function (configuration) {
-    const localVarAxiosParamCreator = VirtualRobotBehaviorApiAxiosParamCreator(configuration);
-    return {
-        /**
-         * <!-- theme: danger -->  > Websocket endpoint  This stream provides the commanded joint state and sets a motion groups joint configuration, e.g. to move a motion group. The concept is that an application is using the Motion Service to move a motion group. The Motion Service is commanding the desired joint configuration of a motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! It is __not__ providing the *actual* joint state! (Please file a request - if you need a stream of the *actual* joint state)  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configurations. CAUTION: Incoming joint configurations are not visualized and their velocity limits are not checked. we don\'t even check limits!  Possible use cases are: 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion group.  The stream only sends data to the robot controller if a motion is executed.  If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity.  2. Mimic Freedrive motions.  <!-- theme: danger -->  > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits.
-         * @summary Stream Joint Configuration
-         * @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 {ExternalJointStreamDatapoint} externalJointStreamDatapoint
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async externalJointsStream(cell, controller, externalJointStreamDatapoint, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.externalJointsStream(cell, controller, externalJointStreamDatapoint, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotBehaviorApi.externalJointsStream']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Get the current robot motion group behavior - please see the setter [setMotionGroupBehavior](setMotionGroupBehavior) and the enum for details.
-         * @summary Behavior
-         * @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 {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getMotionGroupBehavior(cell, controller, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getMotionGroupBehavior(cell, controller, motionGroup, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotBehaviorApi.getMotionGroupBehavior']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Switch robot motion group behavior.
-         * @summary Switch Behavior
-         * @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 {string} motionGroup The motion-group identifier.
-         * @param {Behavior} [behavior]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async setMotionGroupBehavior(cell, controller, motionGroup, behavior, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.setMotionGroupBehavior(cell, controller, motionGroup, behavior, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotBehaviorApi.setMotionGroupBehavior']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-    };
-};
-/**
- * VirtualRobotBehaviorApi - factory interface
- * @export
- */
-export const VirtualRobotBehaviorApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = VirtualRobotBehaviorApiFp(configuration);
-    return {
-        /**
-         * <!-- theme: danger -->  > Websocket endpoint  This stream provides the commanded joint state and sets a motion groups joint configuration, e.g. to move a motion group. The concept is that an application is using the Motion Service to move a motion group. The Motion Service is commanding the desired joint configuration of a motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! It is __not__ providing the *actual* joint state! (Please file a request - if you need a stream of the *actual* joint state)  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configurations. CAUTION: Incoming joint configurations are not visualized and their velocity limits are not checked. we don\'t even check limits!  Possible use cases are: 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion group.  The stream only sends data to the robot controller if a motion is executed.  If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity.  2. Mimic Freedrive motions.  <!-- theme: danger -->  > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits.
-         * @summary Stream Joint Configuration
-         * @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 {ExternalJointStreamDatapoint} externalJointStreamDatapoint
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        externalJointsStream(cell, controller, externalJointStreamDatapoint, options) {
-            return localVarFp.externalJointsStream(cell, controller, externalJointStreamDatapoint, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Get the current robot motion group behavior - please see the setter [setMotionGroupBehavior](setMotionGroupBehavior) and the enum for details.
-         * @summary Behavior
-         * @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 {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getMotionGroupBehavior(cell, controller, motionGroup, options) {
-            return localVarFp.getMotionGroupBehavior(cell, controller, motionGroup, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Switch robot motion group behavior.
-         * @summary Switch Behavior
-         * @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 {string} motionGroup The motion-group identifier.
-         * @param {Behavior} [behavior]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        setMotionGroupBehavior(cell, controller, motionGroup, behavior, options) {
-            return localVarFp.setMotionGroupBehavior(cell, controller, motionGroup, behavior, options).then((request) => request(axios, basePath));
-        },
-    };
-};
-/**
- * VirtualRobotBehaviorApi - object-oriented interface
- * @export
- * @class VirtualRobotBehaviorApi
- * @extends {BaseAPI}
- */
-export class VirtualRobotBehaviorApi extends BaseAPI {
-    /**
-     * <!-- theme: danger -->  > Websocket endpoint  This stream provides the commanded joint state and sets a motion groups joint configuration, e.g. to move a motion group. The concept is that an application is using the Motion Service to move a motion group. The Motion Service is commanding the desired joint configuration of a motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! It is __not__ providing the *actual* joint state! (Please file a request - if you need a stream of the *actual* joint state)  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configurations. CAUTION: Incoming joint configurations are not visualized and their velocity limits are not checked. we don\'t even check limits!  Possible use cases are: 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion group.  The stream only sends data to the robot controller if a motion is executed.  If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity.  2. Mimic Freedrive motions.  <!-- theme: danger -->  > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits.
-     * @summary Stream Joint Configuration
-     * @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 {ExternalJointStreamDatapoint} externalJointStreamDatapoint
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof VirtualRobotBehaviorApi
-     */
-    externalJointsStream(cell, controller, externalJointStreamDatapoint, options) {
-        return VirtualRobotBehaviorApiFp(this.configuration).externalJointsStream(cell, controller, externalJointStreamDatapoint, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Get the current robot motion group behavior - please see the setter [setMotionGroupBehavior](setMotionGroupBehavior) and the enum for details.
-     * @summary Behavior
-     * @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 {string} motionGroup The motion-group identifier.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof VirtualRobotBehaviorApi
-     */
-    getMotionGroupBehavior(cell, controller, motionGroup, options) {
-        return VirtualRobotBehaviorApiFp(this.configuration).getMotionGroupBehavior(cell, controller, motionGroup, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Switch robot motion group behavior.
-     * @summary Switch Behavior
-     * @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 {string} motionGroup The motion-group identifier.
-     * @param {Behavior} [behavior]
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof VirtualRobotBehaviorApi
-     */
-    setMotionGroupBehavior(cell, controller, motionGroup, behavior, options) {
-        return VirtualRobotBehaviorApiFp(this.configuration).setMotionGroupBehavior(cell, controller, motionGroup, behavior, options).then((request) => request(this.axios, this.basePath));
-    }
-}
-/**
- * VirtualRobotModeApi - axios parameter creator
- * @export
- */
-export const VirtualRobotModeApiAxiosParamCreator = function (configuration) {
-    return {
+            assertParamExists('getOperationMode', 'cell', cell);
+            // verify required parameter 'controller' is not null or undefined
+            assertParamExists('getOperationMode', 'controller', controller);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/operationmode`
+                .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 = {};
+            const localVarQueryParameter = {};
+            // 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 cycle time of controller communication in [ms].
-         * @summary Cycle Time
+         * Gets motion group mounting. The motion group is based on the origin of the returned coordinate system.
+         * @summary Get Mounting
          * @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 {string} motionGroup The motion-group identifier.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getCycleTime: async (cell, controller, options = {}) => {
+        getVirtualControllerMounting: async (cell, controller, motionGroup, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getCycleTime', 'cell', cell);
+            assertParamExists('getVirtualControllerMounting', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getCycleTime', 'controller', controller);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/cycle-time`
+            assertParamExists('getVirtualControllerMounting', 'controller', controller);
+            // verify required parameter 'motionGroup' is not null or undefined
+            assertParamExists('getVirtualControllerMounting', 'motionGroup', motionGroup);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/motion-groups/{motion-group}/mounting`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
+                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
+                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -8203,19 +7862,19 @@ export const VirtualRobotModeApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Requests the Emergency Stop state of the virtual robot controller.  Use [getCurrentMotionGroupState](getCurrentMotionGroupState) to get the Emergency Stop state regardless of the controller type. There the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed when using virtual robot controllers.
-         * @summary Get Emergency Stop State
+         * Lists all coordinate systems on the robot controller.
+         * @summary List Coordinate Systems
          * @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}
          */
-        getEmergencyStop: async (cell, controller, options = {}) => {
+        listVirtualControllerCoordinateSystems: async (cell, controller, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getEmergencyStop', 'cell', cell);
+            assertParamExists('listVirtualControllerCoordinateSystems', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getEmergencyStop', 'controller', controller);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/emergency-stop`
+            assertParamExists('listVirtualControllerCoordinateSystems', 'controller', controller);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/coordinate-systems`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -8242,21 +7901,25 @@ export const VirtualRobotModeApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Requests the Operation Mode of the virtual robot controller.  To get the Operation Mode regardless of the controller type use [getCurrentMotionGroupState](getCurrentMotionGroupState).  **Note:** The Operating Mode can only change be changed via API when using virtual robot controllers.
-         * @summary Get Operation Mode
+         * Lists TCPs of the motion group. An empty TCP list is valid, for example for external axes.
+         * @summary List TCPs
          * @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 {string} motionGroup The motion-group identifier.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getOperationMode: async (cell, controller, options = {}) => {
+        listVirtualControllerTcps: async (cell, controller, motionGroup, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getOperationMode', 'cell', cell);
+            assertParamExists('listVirtualControllerTcps', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getOperationMode', 'controller', controller);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/operationmode`
+            assertParamExists('listVirtualControllerTcps', 'controller', controller);
+            // verify required parameter 'motionGroup' is not null or undefined
+            assertParamExists('listVirtualControllerTcps', 'motionGroup', motionGroup);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/motion-groups/{motion-group}/tcps`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
+                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
+                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -8294,7 +7957,7 @@ export const VirtualRobotModeApiAxiosParamCreator = function (configuration) {
             assertParamExists('setEmergencyStop', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
             assertParamExists('setEmergencyStop', 'controller', controller);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/emergency-stop`
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/emergency-stop`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -8323,6 +7986,54 @@ export const VirtualRobotModeApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Sets the values for joint position, joint velocity or joint acceleration of a motion group state. The values are immediately applied to the joints of the motion group. We recommend to only use the endpoint when the motion group is in monitor mode. In case the motion group is controlled, currently jogging or planning motions, the values are overridden by the controller or an error may occur.
+         * @summary Set Motion Group 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 {string} motionGroup The motion-group identifier.
+         * @param {MotionGroupJoints} motionGroupJoints
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        setMotionGroupState: async (cell, controller, motionGroup, motionGroupJoints, options = {}) => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('setMotionGroupState', 'cell', cell);
+            // verify required parameter 'controller' is not null or undefined
+            assertParamExists('setMotionGroupState', 'controller', controller);
+            // verify required parameter 'motionGroup' is not null or undefined
+            assertParamExists('setMotionGroupState', 'motionGroup', motionGroup);
+            // verify required parameter 'motionGroupJoints' is not null or undefined
+            assertParamExists('setMotionGroupState', 'motionGroupJoints', motionGroupJoints);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/motion-groups/{motion-group}/state`
+                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
+                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
+                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
+            // 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 = {};
+            const localVarQueryParameter = {};
+            // 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(motionGroupJoints, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * Changes the Operation Mode of the virtual robot controller to the specified value.  To get the Operation Mode regardless of the controller type use [getCurrentMotionGroupState](getCurrentMotionGroupState).  > **NOTE** > > The Operating Mode can only change be changed via API when using virtual robot controllers.
          * @summary Set Operation Mode
@@ -8339,7 +8050,7 @@ export const VirtualRobotModeApiAxiosParamCreator = function (configuration) {
             assertParamExists('setOperationMode', 'controller', controller);
             // verify required parameter 'mode' is not null or undefined
             assertParamExists('setOperationMode', 'mode', mode);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/operationmode`
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/operationmode`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -8368,55 +8079,227 @@ export const VirtualRobotModeApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Sets motion group mounting by specifying a coordinate system. The motion group will be based on the coordinate system\'s origin. The coordinate system defines a transformation offset. The transformation offset is defined by a unique identifier, a name for front end usage and an offset in another coordinate system referenced by the unique identifier of the reference coordinate system.
+         * @summary Set Mounting
+         * @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 {string} motionGroup The motion-group identifier.
+         * @param {CoordinateSystem} coordinateSystem
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        setVirtualControllerMounting: async (cell, controller, motionGroup, coordinateSystem, options = {}) => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('setVirtualControllerMounting', 'cell', cell);
+            // verify required parameter 'controller' is not null or undefined
+            assertParamExists('setVirtualControllerMounting', 'controller', controller);
+            // verify required parameter 'motionGroup' is not null or undefined
+            assertParamExists('setVirtualControllerMounting', 'motionGroup', motionGroup);
+            // verify required parameter 'coordinateSystem' is not null or undefined
+            assertParamExists('setVirtualControllerMounting', 'coordinateSystem', coordinateSystem);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/motion-groups/{motion-group}/mounting`
+                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
+                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
+                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
+            // 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 = {};
+            const localVarQueryParameter = {};
+            // 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(coordinateSystem, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
     };
 };
 /**
- * VirtualRobotModeApi - functional programming interface
+ * VirtualControllerApi - functional programming interface
  * @export
  */
-export const VirtualRobotModeApiFp = function (configuration) {
-    const localVarAxiosParamCreator = VirtualRobotModeApiAxiosParamCreator(configuration);
+export const VirtualControllerApiFp = function (configuration) {
+    const localVarAxiosParamCreator = VirtualControllerApiAxiosParamCreator(configuration);
     return {
         /**
-         * Get the cycle time of controller communication in [ms].
-         * @summary Cycle Time
+         * Adds a coordinate system to the robot controller.
+         * @summary Add Coordinate Systems
          * @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 {string} coordinateSystem Unique identifier addressing a coordinate system.
+         * @param {CoordinateSystemData} coordinateSystemData
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async getCycleTime(cell, controller, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getCycleTime(cell, controller, options);
+        async addVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.addVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.addVirtualControllerCoordinateSystem']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Adds a new TCP or updates an existing TCP in the motion group.  The position and rotation values in the request body are defined within the flange’s coordinate system.  > **NOTE** > > Ensure the TCP\'s position is within the robot\'s reach. Refer to the robot’s documentation or data sheet for details like joint limits or reach.
+         * @summary Add TCP
+         * @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 {string} motionGroup The motion-group identifier.
+         * @param {string} tcp The unique identifier of a TCP.
+         * @param {RobotTcpData} robotTcpData
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async addVirtualControllerTcp(cell, controller, motionGroup, tcp, robotTcpData, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.addVirtualControllerTcp(cell, controller, motionGroup, tcp, robotTcpData, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.addVirtualControllerTcp']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Deletes a coordinate system from the virtual controller. This will remove the coordinate system from the list of coordinate systems and remove all dependent coordinate systems which use the deleted coordinate system as reference.
+         * @summary Remove Coordinate System
+         * @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 {string} coordinateSystem Unique identifier addressing a coordinate system.
+         * @param {boolean} [deleteDependent] If true, all dependent coordinate systems will be deleted as well.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async deleteVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.deleteVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.deleteVirtualControllerCoordinateSystem']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Removes the TCP from the motion group. An unknown TCP is a valid input.
+         * @summary Remove TCP
+         * @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 {string} motionGroup The motion-group identifier.
+         * @param {string} tcp The unique identifier of a TCP.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async deleteVirtualControllerTcp(cell, controller, motionGroup, tcp, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.deleteVirtualControllerTcp(cell, controller, motionGroup, tcp, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.deleteVirtualControllerTcp']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Requests the Emergency Stop state of the virtual robot controller.  Use [getCurrentMotionGroupState](getCurrentMotionGroupState) to get the Emergency Stop state regardless of the controller type. There the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed when using virtual robot controllers.
+         * @summary Get Emergency Stop 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 {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getEmergencyStop(cell, controller, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getEmergencyStop(cell, controller, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.getEmergencyStop']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Get the current motion group state which provides values for the joints\' position, velocity and acceleration.
+         * @summary Get Motion Group 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 {string} motionGroup The motion-group identifier.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getMotionGroupState(cell, controller, motionGroup, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getMotionGroupState(cell, controller, motionGroup, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.getMotionGroupState']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Gets information on the motion group.
+         * @summary Motion Group Description
+         * @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 getMotionGroups(cell, controller, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getMotionGroups(cell, controller, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.getMotionGroups']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Requests the Operation Mode of the virtual robot controller.  To get the Operation Mode regardless of the controller type use [getCurrentMotionGroupState](getCurrentMotionGroupState).  **Note:** The Operating Mode can only change be changed via API when using virtual robot controllers.
+         * @summary Get Operation 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 getOperationMode(cell, controller, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getOperationMode(cell, controller, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.getOperationMode']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Gets motion group mounting. The motion group is based on the origin of the returned coordinate system.
+         * @summary Get Mounting
+         * @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 {string} motionGroup The motion-group identifier.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getVirtualControllerMounting(cell, controller, motionGroup, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getVirtualControllerMounting(cell, controller, motionGroup, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotModeApi.getCycleTime']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.getVirtualControllerMounting']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Requests the Emergency Stop state of the virtual robot controller.  Use [getCurrentMotionGroupState](getCurrentMotionGroupState) to get the Emergency Stop state regardless of the controller type. There the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed when using virtual robot controllers.
-         * @summary Get Emergency Stop State
+         * Lists all coordinate systems on the robot controller.
+         * @summary List Coordinate Systems
          * @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 getEmergencyStop(cell, controller, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getEmergencyStop(cell, controller, options);
+        async listVirtualControllerCoordinateSystems(cell, controller, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listVirtualControllerCoordinateSystems(cell, controller, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotModeApi.getEmergencyStop']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.listVirtualControllerCoordinateSystems']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Requests the Operation Mode of the virtual robot controller.  To get the Operation Mode regardless of the controller type use [getCurrentMotionGroupState](getCurrentMotionGroupState).  **Note:** The Operating Mode can only change be changed via API when using virtual robot controllers.
-         * @summary Get Operation Mode
+         * Lists TCPs of the motion group. An empty TCP list is valid, for example for external axes.
+         * @summary List TCPs
          * @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 {string} motionGroup The motion-group identifier.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async getOperationMode(cell, controller, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getOperationMode(cell, controller, options);
+        async listVirtualControllerTcps(cell, controller, motionGroup, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listVirtualControllerTcps(cell, controller, motionGroup, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotModeApi.getOperationMode']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.listVirtualControllerTcps']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -8431,7 +8314,23 @@ export const VirtualRobotModeApiFp = function (configuration) {
         async setEmergencyStop(cell, controller, active, options) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.setEmergencyStop(cell, controller, active, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotModeApi.setEmergencyStop']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.setEmergencyStop']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Sets the values for joint position, joint velocity or joint acceleration of a motion group state. The values are immediately applied to the joints of the motion group. We recommend to only use the endpoint when the motion group is in monitor mode. In case the motion group is controlled, currently jogging or planning motions, the values are overridden by the controller or an error may occur.
+         * @summary Set Motion Group 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 {string} motionGroup The motion-group identifier.
+         * @param {MotionGroupJoints} motionGroupJoints
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async setMotionGroupState(cell, controller, motionGroup, motionGroupJoints, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.setMotionGroupState(cell, controller, motionGroup, motionGroupJoints, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.setMotionGroupState']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -8446,28 +8345,86 @@ export const VirtualRobotModeApiFp = function (configuration) {
         async setOperationMode(cell, controller, mode, options) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.setOperationMode(cell, controller, mode, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotModeApi.setOperationMode']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.setOperationMode']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Sets motion group mounting by specifying a coordinate system. The motion group will be based on the coordinate system\'s origin. The coordinate system defines a transformation offset. The transformation offset is defined by a unique identifier, a name for front end usage and an offset in another coordinate system referenced by the unique identifier of the reference coordinate system.
+         * @summary Set Mounting
+         * @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 {string} motionGroup The motion-group identifier.
+         * @param {CoordinateSystem} coordinateSystem
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async setVirtualControllerMounting(cell, controller, motionGroup, coordinateSystem, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.setVirtualControllerMounting(cell, controller, motionGroup, coordinateSystem, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.setVirtualControllerMounting']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     };
 };
 /**
- * VirtualRobotModeApi - factory interface
+ * VirtualControllerApi - factory interface
  * @export
  */
-export const VirtualRobotModeApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = VirtualRobotModeApiFp(configuration);
+export const VirtualControllerApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = VirtualControllerApiFp(configuration);
     return {
         /**
-         * Get the cycle time of controller communication in [ms].
-         * @summary Cycle Time
+         * Adds a coordinate system to the robot controller.
+         * @summary Add Coordinate Systems
          * @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 {string} coordinateSystem Unique identifier addressing a coordinate system.
+         * @param {CoordinateSystemData} coordinateSystemData
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getCycleTime(cell, controller, options) {
-            return localVarFp.getCycleTime(cell, controller, options).then((request) => request(axios, basePath));
+        addVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options) {
+            return localVarFp.addVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Adds a new TCP or updates an existing TCP in the motion group.  The position and rotation values in the request body are defined within the flange’s coordinate system.  > **NOTE** > > Ensure the TCP\'s position is within the robot\'s reach. Refer to the robot’s documentation or data sheet for details like joint limits or reach.
+         * @summary Add TCP
+         * @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 {string} motionGroup The motion-group identifier.
+         * @param {string} tcp The unique identifier of a TCP.
+         * @param {RobotTcpData} robotTcpData
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        addVirtualControllerTcp(cell, controller, motionGroup, tcp, robotTcpData, options) {
+            return localVarFp.addVirtualControllerTcp(cell, controller, motionGroup, tcp, robotTcpData, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Deletes a coordinate system from the virtual controller. This will remove the coordinate system from the list of coordinate systems and remove all dependent coordinate systems which use the deleted coordinate system as reference.
+         * @summary Remove Coordinate System
+         * @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 {string} coordinateSystem Unique identifier addressing a coordinate system.
+         * @param {boolean} [deleteDependent] If true, all dependent coordinate systems will be deleted as well.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        deleteVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options) {
+            return localVarFp.deleteVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Removes the TCP from the motion group. An unknown TCP is a valid input.
+         * @summary Remove TCP
+         * @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 {string} motionGroup The motion-group identifier.
+         * @param {string} tcp The unique identifier of a TCP.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        deleteVirtualControllerTcp(cell, controller, motionGroup, tcp, options) {
+            return localVarFp.deleteVirtualControllerTcp(cell, controller, motionGroup, tcp, options).then((request) => request(axios, basePath));
         },
         /**
          * Requests the Emergency Stop state of the virtual robot controller.  Use [getCurrentMotionGroupState](getCurrentMotionGroupState) to get the Emergency Stop state regardless of the controller type. There the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed when using virtual robot controllers.
@@ -8480,6 +8437,29 @@ export const VirtualRobotModeApiFactory = function (configuration, basePath, axi
         getEmergencyStop(cell, controller, options) {
             return localVarFp.getEmergencyStop(cell, controller, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Get the current motion group state which provides values for the joints\' position, velocity and acceleration.
+         * @summary Get Motion Group 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 {string} motionGroup The motion-group identifier.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getMotionGroupState(cell, controller, motionGroup, options) {
+            return localVarFp.getMotionGroupState(cell, controller, motionGroup, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Gets information on the motion group.
+         * @summary Motion Group Description
+         * @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}
+         */
+        getMotionGroups(cell, controller, options) {
+            return localVarFp.getMotionGroups(cell, controller, options).then((request) => request(axios, basePath));
+        },
         /**
          * Requests the Operation Mode of the virtual robot controller.  To get the Operation Mode regardless of the controller type use [getCurrentMotionGroupState](getCurrentMotionGroupState).  **Note:** The Operating Mode can only change be changed via API when using virtual robot controllers.
          * @summary Get Operation Mode
@@ -8491,6 +8471,41 @@ export const VirtualRobotModeApiFactory = function (configuration, basePath, axi
         getOperationMode(cell, controller, options) {
             return localVarFp.getOperationMode(cell, controller, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Gets motion group mounting. The motion group is based on the origin of the returned coordinate system.
+         * @summary Get Mounting
+         * @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 {string} motionGroup The motion-group identifier.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getVirtualControllerMounting(cell, controller, motionGroup, options) {
+            return localVarFp.getVirtualControllerMounting(cell, controller, motionGroup, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Lists all coordinate systems on the robot controller.
+         * @summary List Coordinate Systems
+         * @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}
+         */
+        listVirtualControllerCoordinateSystems(cell, controller, options) {
+            return localVarFp.listVirtualControllerCoordinateSystems(cell, controller, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Lists TCPs of the motion group. An empty TCP list is valid, for example for external axes.
+         * @summary List TCPs
+         * @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 {string} motionGroup The motion-group identifier.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listVirtualControllerTcps(cell, controller, motionGroup, options) {
+            return localVarFp.listVirtualControllerTcps(cell, controller, motionGroup, options).then((request) => request(axios, basePath));
+        },
         /**
          * Activates or releases the Emergency Stop on the virtual robot controller.  Activating the Emergency Stop stops the execution of all motions. The stop is executed on physical controllers immediately not gracefully and not on paths. Due to restricted physical behavior of the virtual robot controller, the Emergency Stop is executed on paths. To return to normal operation the Emergency Stop needs to be released.  Use [getCurrentMotionGroupState](getCurrentMotionGroupState) to get the Emergency Stop state regardless of the controller type. There the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed via API when using virtual robot controllers.
          * @summary Push or Release Emergency Stop
@@ -8503,6 +8518,19 @@ export const VirtualRobotModeApiFactory = function (configuration, basePath, axi
         setEmergencyStop(cell, controller, active, options) {
             return localVarFp.setEmergencyStop(cell, controller, active, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Sets the values for joint position, joint velocity or joint acceleration of a motion group state. The values are immediately applied to the joints of the motion group. We recommend to only use the endpoint when the motion group is in monitor mode. In case the motion group is controlled, currently jogging or planning motions, the values are overridden by the controller or an error may occur.
+         * @summary Set Motion Group 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 {string} motionGroup The motion-group identifier.
+         * @param {MotionGroupJoints} motionGroupJoints
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        setMotionGroupState(cell, controller, motionGroup, motionGroupJoints, options) {
+            return localVarFp.setMotionGroupState(cell, controller, motionGroup, motionGroupJoints, options).then((request) => request(axios, basePath));
+        },
         /**
          * Changes the Operation Mode of the virtual robot controller to the specified value.  To get the Operation Mode regardless of the controller type use [getCurrentMotionGroupState](getCurrentMotionGroupState).  > **NOTE** > > The Operating Mode can only change be changed via API when using virtual robot controllers.
          * @summary Set Operation Mode
@@ -8515,26 +8543,84 @@ export const VirtualRobotModeApiFactory = function (configuration, basePath, axi
         setOperationMode(cell, controller, mode, options) {
             return localVarFp.setOperationMode(cell, controller, mode, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Sets motion group mounting by specifying a coordinate system. The motion group will be based on the coordinate system\'s origin. The coordinate system defines a transformation offset. The transformation offset is defined by a unique identifier, a name for front end usage and an offset in another coordinate system referenced by the unique identifier of the reference coordinate system.
+         * @summary Set Mounting
+         * @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 {string} motionGroup The motion-group identifier.
+         * @param {CoordinateSystem} coordinateSystem
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        setVirtualControllerMounting(cell, controller, motionGroup, coordinateSystem, options) {
+            return localVarFp.setVirtualControllerMounting(cell, controller, motionGroup, coordinateSystem, options).then((request) => request(axios, basePath));
+        },
     };
 };
 /**
- * VirtualRobotModeApi - object-oriented interface
+ * VirtualControllerApi - object-oriented interface
  * @export
- * @class VirtualRobotModeApi
+ * @class VirtualControllerApi
  * @extends {BaseAPI}
  */
-export class VirtualRobotModeApi extends BaseAPI {
+export class VirtualControllerApi extends BaseAPI {
     /**
-     * Get the cycle time of controller communication in [ms].
-     * @summary Cycle Time
+     * Adds a coordinate system to the robot controller.
+     * @summary Add Coordinate Systems
      * @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 {string} coordinateSystem Unique identifier addressing a coordinate system.
+     * @param {CoordinateSystemData} coordinateSystemData
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof VirtualRobotModeApi
+     * @memberof VirtualControllerApi
      */
-    getCycleTime(cell, controller, options) {
-        return VirtualRobotModeApiFp(this.configuration).getCycleTime(cell, controller, options).then((request) => request(this.axios, this.basePath));
+    addVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options) {
+        return VirtualControllerApiFp(this.configuration).addVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Adds a new TCP or updates an existing TCP in the motion group.  The position and rotation values in the request body are defined within the flange’s coordinate system.  > **NOTE** > > Ensure the TCP\'s position is within the robot\'s reach. Refer to the robot’s documentation or data sheet for details like joint limits or reach.
+     * @summary Add TCP
+     * @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 {string} motionGroup The motion-group identifier.
+     * @param {string} tcp The unique identifier of a TCP.
+     * @param {RobotTcpData} robotTcpData
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof VirtualControllerApi
+     */
+    addVirtualControllerTcp(cell, controller, motionGroup, tcp, robotTcpData, options) {
+        return VirtualControllerApiFp(this.configuration).addVirtualControllerTcp(cell, controller, motionGroup, tcp, robotTcpData, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Deletes a coordinate system from the virtual controller. This will remove the coordinate system from the list of coordinate systems and remove all dependent coordinate systems which use the deleted coordinate system as reference.
+     * @summary Remove Coordinate System
+     * @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 {string} coordinateSystem Unique identifier addressing a coordinate system.
+     * @param {boolean} [deleteDependent] If true, all dependent coordinate systems will be deleted as well.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof VirtualControllerApi
+     */
+    deleteVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options) {
+        return VirtualControllerApiFp(this.configuration).deleteVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Removes the TCP from the motion group. An unknown TCP is a valid input.
+     * @summary Remove TCP
+     * @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 {string} motionGroup The motion-group identifier.
+     * @param {string} tcp The unique identifier of a TCP.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof VirtualControllerApi
+     */
+    deleteVirtualControllerTcp(cell, controller, motionGroup, tcp, options) {
+        return VirtualControllerApiFp(this.configuration).deleteVirtualControllerTcp(cell, controller, motionGroup, tcp, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * Requests the Emergency Stop state of the virtual robot controller.  Use [getCurrentMotionGroupState](getCurrentMotionGroupState) to get the Emergency Stop state regardless of the controller type. There the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed when using virtual robot controllers.
@@ -8543,10 +8629,35 @@ export class VirtualRobotModeApi extends BaseAPI {
      * @param {string} controller Unique identifier to address a controller in the cell.
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof VirtualRobotModeApi
+     * @memberof VirtualControllerApi
      */
     getEmergencyStop(cell, controller, options) {
-        return VirtualRobotModeApiFp(this.configuration).getEmergencyStop(cell, controller, options).then((request) => request(this.axios, this.basePath));
+        return VirtualControllerApiFp(this.configuration).getEmergencyStop(cell, controller, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Get the current motion group state which provides values for the joints\' position, velocity and acceleration.
+     * @summary Get Motion Group 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 {string} motionGroup The motion-group identifier.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof VirtualControllerApi
+     */
+    getMotionGroupState(cell, controller, motionGroup, options) {
+        return VirtualControllerApiFp(this.configuration).getMotionGroupState(cell, controller, motionGroup, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Gets information on the motion group.
+     * @summary Motion Group Description
+     * @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 VirtualControllerApi
+     */
+    getMotionGroups(cell, controller, options) {
+        return VirtualControllerApiFp(this.configuration).getMotionGroups(cell, controller, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * Requests the Operation Mode of the virtual robot controller.  To get the Operation Mode regardless of the controller type use [getCurrentMotionGroupState](getCurrentMotionGroupState).  **Note:** The Operating Mode can only change be changed via API when using virtual robot controllers.
@@ -8555,10 +8666,48 @@ export class VirtualRobotModeApi extends BaseAPI {
      * @param {string} controller Unique identifier to address a controller in the cell.
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof VirtualRobotModeApi
+     * @memberof VirtualControllerApi
      */
     getOperationMode(cell, controller, options) {
-        return VirtualRobotModeApiFp(this.configuration).getOperationMode(cell, controller, options).then((request) => request(this.axios, this.basePath));
+        return VirtualControllerApiFp(this.configuration).getOperationMode(cell, controller, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Gets motion group mounting. The motion group is based on the origin of the returned coordinate system.
+     * @summary Get Mounting
+     * @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 {string} motionGroup The motion-group identifier.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof VirtualControllerApi
+     */
+    getVirtualControllerMounting(cell, controller, motionGroup, options) {
+        return VirtualControllerApiFp(this.configuration).getVirtualControllerMounting(cell, controller, motionGroup, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Lists all coordinate systems on the robot controller.
+     * @summary List Coordinate Systems
+     * @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 VirtualControllerApi
+     */
+    listVirtualControllerCoordinateSystems(cell, controller, options) {
+        return VirtualControllerApiFp(this.configuration).listVirtualControllerCoordinateSystems(cell, controller, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Lists TCPs of the motion group. An empty TCP list is valid, for example for external axes.
+     * @summary List TCPs
+     * @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 {string} motionGroup The motion-group identifier.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof VirtualControllerApi
+     */
+    listVirtualControllerTcps(cell, controller, motionGroup, options) {
+        return VirtualControllerApiFp(this.configuration).listVirtualControllerTcps(cell, controller, motionGroup, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * Activates or releases the Emergency Stop on the virtual robot controller.  Activating the Emergency Stop stops the execution of all motions. The stop is executed on physical controllers immediately not gracefully and not on paths. Due to restricted physical behavior of the virtual robot controller, the Emergency Stop is executed on paths. To return to normal operation the Emergency Stop needs to be released.  Use [getCurrentMotionGroupState](getCurrentMotionGroupState) to get the Emergency Stop state regardless of the controller type. There the Emergency Stop state is visible as the `safety_state`.  > **NOTE** > > The Emergency Stop state can only be changed via API when using virtual robot controllers.
@@ -8568,10 +8717,24 @@ export class VirtualRobotModeApi extends BaseAPI {
      * @param {boolean} [active]
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof VirtualRobotModeApi
+     * @memberof VirtualControllerApi
+     */
+    setEmergencyStop(cell, controller, active, options) {
+        return VirtualControllerApiFp(this.configuration).setEmergencyStop(cell, controller, active, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Sets the values for joint position, joint velocity or joint acceleration of a motion group state. The values are immediately applied to the joints of the motion group. We recommend to only use the endpoint when the motion group is in monitor mode. In case the motion group is controlled, currently jogging or planning motions, the values are overridden by the controller or an error may occur.
+     * @summary Set Motion Group 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 {string} motionGroup The motion-group identifier.
+     * @param {MotionGroupJoints} motionGroupJoints
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof VirtualControllerApi
      */
-    setEmergencyStop(cell, controller, active, options) {
-        return VirtualRobotModeApiFp(this.configuration).setEmergencyStop(cell, controller, active, options).then((request) => request(this.axios, this.basePath));
+    setMotionGroupState(cell, controller, motionGroup, motionGroupJoints, options) {
+        return VirtualControllerApiFp(this.configuration).setMotionGroupState(cell, controller, motionGroup, motionGroupJoints, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * Changes the Operation Mode of the virtual robot controller to the specified value.  To get the Operation Mode regardless of the controller type use [getCurrentMotionGroupState](getCurrentMotionGroupState).  > **NOTE** > > The Operating Mode can only change be changed via API when using virtual robot controllers.
@@ -8581,35 +8744,49 @@ export class VirtualRobotModeApi extends BaseAPI {
      * @param {OperationMode} mode
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof VirtualRobotModeApi
+     * @memberof VirtualControllerApi
      */
     setOperationMode(cell, controller, mode, options) {
-        return VirtualRobotModeApiFp(this.configuration).setOperationMode(cell, controller, mode, options).then((request) => request(this.axios, this.basePath));
+        return VirtualControllerApiFp(this.configuration).setOperationMode(cell, controller, mode, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Sets motion group mounting by specifying a coordinate system. The motion group will be based on the coordinate system\'s origin. The coordinate system defines a transformation offset. The transformation offset is defined by a unique identifier, a name for front end usage and an offset in another coordinate system referenced by the unique identifier of the reference coordinate system.
+     * @summary Set Mounting
+     * @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 {string} motionGroup The motion-group identifier.
+     * @param {CoordinateSystem} coordinateSystem
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof VirtualControllerApi
+     */
+    setVirtualControllerMounting(cell, controller, motionGroup, coordinateSystem, options) {
+        return VirtualControllerApiFp(this.configuration).setVirtualControllerMounting(cell, controller, motionGroup, coordinateSystem, options).then((request) => request(this.axios, this.basePath));
     }
 }
 /**
- * VirtualRobotSetupApi - axios parameter creator
+ * VirtualControllerBehaviorApi - axios parameter creator
  * @export
  */
-export const VirtualRobotSetupApiAxiosParamCreator = function (configuration) {
+export const VirtualControllerBehaviorApiAxiosParamCreator = function (configuration) {
     return {
         /**
-         * Adds a coordinate system to the robot controller.
-         * @summary Add Coordinate Systems
+         * <!-- theme: danger -->  > Websocket endpoint  This stream sends the commanded state (joint positions, velocities, accelerations, torques) for each motion group of the virtual controller and sets the joint configuration. Moving motion groups on virtual controllers can be executed by using Trajectory Planning and Trajectory Execution. Trajectory Execution commands the desired joint configuration to each motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! > **NOTE** > > This stream provides *commanded* joint states, it **doesn\'t provide actual joint states**.  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configuration. > **CAUTION** > > Incoming joint configurations are not visualized and their velocity limits are not checked.  Possible use cases are: 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion groups.  The stream only sends data to the robot controller if a motion is executed.  If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity.  2. Mimic Freedrive motions.  <!-- theme: danger -->  > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits.
+         * @summary Stream Joint Configuration
          * @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 {CoordinateSystem} coordinateSystem
+         * @param {ExternalJointStreamRequest} externalJointStreamRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        addVirtualRobotCoordinateSystem: async (cell, controller, coordinateSystem, options = {}) => {
+        externalJointsStream: async (cell, controller, externalJointStreamRequest, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('addVirtualRobotCoordinateSystem', 'cell', cell);
+            assertParamExists('externalJointsStream', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('addVirtualRobotCoordinateSystem', 'controller', controller);
-            // verify required parameter 'coordinateSystem' is not null or undefined
-            assertParamExists('addVirtualRobotCoordinateSystem', 'coordinateSystem', coordinateSystem);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/coordinate-systems`
+            assertParamExists('externalJointsStream', 'controller', controller);
+            // verify required parameter 'externalJointStreamRequest' is not null or undefined
+            assertParamExists('externalJointsStream', 'externalJointStreamRequest', externalJointStreamRequest);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/external-joints-stream`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -8618,7 +8795,7 @@ export const VirtualRobotSetupApiAxiosParamCreator = function (configuration) {
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -8631,42 +8808,35 @@ export const VirtualRobotSetupApiAxiosParamCreator = function (configuration) {
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            localVarRequestOptions.data = serializeDataIfNeeded(coordinateSystem, localVarRequestOptions, configuration);
+            localVarRequestOptions.data = serializeDataIfNeeded(externalJointStreamRequest, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
             };
         },
         /**
-         * Adds a new TCP or updates an existing TCP in the motion group.  The position and rotation values in the request body are defined within the flange’s coordinate system.  > **NOTE** > > Ensure the TCP\'s position is within the robot\'s reach. Refer to the robot’s documentation or data sheet for details like joint limits or reach.
-         * @summary Add TCP
+         * Get the cycle time of controller communication in [ms].
+         * @summary Get Cycle Time
          * @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 {string} motionGroup The motion-group identifier.
-         * @param {RobotTcp} robotTcp
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        addVirtualRobotTcp: async (cell, controller, motionGroup, robotTcp, options = {}) => {
+        getCycleTime: async (cell, controller, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('addVirtualRobotTcp', 'cell', cell);
+            assertParamExists('getCycleTime', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('addVirtualRobotTcp', 'controller', controller);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('addVirtualRobotTcp', 'motionGroup', motionGroup);
-            // verify required parameter 'robotTcp' is not null or undefined
-            assertParamExists('addVirtualRobotTcp', 'robotTcp', robotTcp);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/motion-groups/{motion-group}/tcps`
+            assertParamExists('getCycleTime', 'controller', controller);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/cycle-time`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
+                .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: 'PUT', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -8675,44 +8845,37 @@ export const VirtualRobotSetupApiAxiosParamCreator = function (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(robotTcp, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
             };
         },
         /**
-         * Deletes a coordinate system from the virtual controller. This will remove the coordinate system from the list of coordinate systems and remove all dependent coordinate systems which use the deleted coordinate system as reference.
-         * @summary Remove Coordinate System
+         * Get the current virtual controller behavior - please see the setter [setVirtualControllerBehavior](setVirtualControllerBehavior) and the enum for details.
+         * @summary Get Behavior
          * @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 {string} coordinateSystem Unique identifier addressing a coordinate system.
-         * @param {boolean} [deleteDependent] If true, all dependent coordinate systems will be deleted as well.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        deleteVirtualRobotCoordinateSystem: async (cell, controller, coordinateSystem, deleteDependent, options = {}) => {
+        getVirtualControllerBehavior: async (cell, controller, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('deleteVirtualRobotCoordinateSystem', 'cell', cell);
+            assertParamExists('getVirtualControllerBehavior', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('deleteVirtualRobotCoordinateSystem', 'controller', controller);
-            // verify required parameter 'coordinateSystem' is not null or undefined
-            assertParamExists('deleteVirtualRobotCoordinateSystem', 'coordinateSystem', coordinateSystem);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/coordinate-systems/{coordinate-system}`
+            assertParamExists('getVirtualControllerBehavior', 'controller', controller);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/behavior`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
-                .replace(`{${"coordinate-system"}}`, encodeURIComponent(String(coordinateSystem)));
+                .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: 'DELETE', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -8721,9 +8884,6 @@ export const VirtualRobotSetupApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (deleteDependent !== undefined) {
-                localVarQueryParameter['delete_dependent'] = deleteDependent;
-            }
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -8733,36 +8893,29 @@ export const VirtualRobotSetupApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Removes the TCP from the motion group. An unknown TCP is a valid input.
-         * @summary Remove TCP
+         * Set virtual controller behavior.
+         * @summary Set Behavior
          * @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 {string} motionGroup The motion-group identifier.
-         * @param {string} tcp The unique identifier of a TCP.
+         * @param {Behavior} [behavior]
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        deleteVirtualRobotTcp: async (cell, controller, motionGroup, tcp, options = {}) => {
+        setVirtualControllerBehavior: async (cell, controller, behavior, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('deleteVirtualRobotTcp', 'cell', cell);
+            assertParamExists('setVirtualControllerBehavior', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('deleteVirtualRobotTcp', 'controller', controller);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('deleteVirtualRobotTcp', 'motionGroup', motionGroup);
-            // verify required parameter 'tcp' is not null or undefined
-            assertParamExists('deleteVirtualRobotTcp', 'tcp', tcp);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/motion-groups/{motion-group}/tcps/{tcp}`
+            assertParamExists('setVirtualControllerBehavior', 'controller', controller);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/behavior`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)))
-                .replace(`{${"tcp"}}`, encodeURIComponent(String(tcp)));
+                .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: 'DELETE', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -8771,6 +8924,9 @@ export const VirtualRobotSetupApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            if (behavior !== undefined) {
+                localVarQueryParameter['behavior'] = behavior;
+            }
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -8779,63 +8935,211 @@ export const VirtualRobotSetupApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         },
+    };
+};
+/**
+ * VirtualControllerBehaviorApi - functional programming interface
+ * @export
+ */
+export const VirtualControllerBehaviorApiFp = function (configuration) {
+    const localVarAxiosParamCreator = VirtualControllerBehaviorApiAxiosParamCreator(configuration);
+    return {
         /**
-         * Gets motion group mounting. The motion group is based on the origin of the returned coordinate system.
-         * @summary Get Mounting
+         * <!-- theme: danger -->  > Websocket endpoint  This stream sends the commanded state (joint positions, velocities, accelerations, torques) for each motion group of the virtual controller and sets the joint configuration. Moving motion groups on virtual controllers can be executed by using Trajectory Planning and Trajectory Execution. Trajectory Execution commands the desired joint configuration to each motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! > **NOTE** > > This stream provides *commanded* joint states, it **doesn\'t provide actual joint states**.  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configuration. > **CAUTION** > > Incoming joint configurations are not visualized and their velocity limits are not checked.  Possible use cases are: 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion groups.  The stream only sends data to the robot controller if a motion is executed.  If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity.  2. Mimic Freedrive motions.  <!-- theme: danger -->  > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits.
+         * @summary Stream Joint Configuration
          * @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 {string} motionGroup The motion-group identifier.
+         * @param {ExternalJointStreamRequest} externalJointStreamRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getVirtualRobotMounting: async (cell, controller, motionGroup, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getVirtualRobotMounting', 'cell', cell);
-            // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getVirtualRobotMounting', 'controller', controller);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('getVirtualRobotMounting', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/motion-groups/{motion-group}/mounting`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // 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 = {};
-            const localVarQueryParameter = {};
-            // 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,
-            };
+        async externalJointsStream(cell, controller, externalJointStreamRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.externalJointsStream(cell, controller, externalJointStreamRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerBehaviorApi.externalJointsStream']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Lists all coordinate systems on the robot controller.
-         * @summary List Coordinate Systems
+         * Get the cycle time of controller communication in [ms].
+         * @summary Get Cycle Time
+         * @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 getCycleTime(cell, controller, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getCycleTime(cell, controller, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerBehaviorApi.getCycleTime']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Get the current virtual controller behavior - please see the setter [setVirtualControllerBehavior](setVirtualControllerBehavior) and the enum for details.
+         * @summary Get Behavior
+         * @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 getVirtualControllerBehavior(cell, controller, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getVirtualControllerBehavior(cell, controller, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerBehaviorApi.getVirtualControllerBehavior']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Set virtual controller behavior.
+         * @summary Set Behavior
+         * @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 {Behavior} [behavior]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async setVirtualControllerBehavior(cell, controller, behavior, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.setVirtualControllerBehavior(cell, controller, behavior, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerBehaviorApi.setVirtualControllerBehavior']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    };
+};
+/**
+ * VirtualControllerBehaviorApi - factory interface
+ * @export
+ */
+export const VirtualControllerBehaviorApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = VirtualControllerBehaviorApiFp(configuration);
+    return {
+        /**
+         * <!-- theme: danger -->  > Websocket endpoint  This stream sends the commanded state (joint positions, velocities, accelerations, torques) for each motion group of the virtual controller and sets the joint configuration. Moving motion groups on virtual controllers can be executed by using Trajectory Planning and Trajectory Execution. Trajectory Execution commands the desired joint configuration to each motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! > **NOTE** > > This stream provides *commanded* joint states, it **doesn\'t provide actual joint states**.  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configuration. > **CAUTION** > > Incoming joint configurations are not visualized and their velocity limits are not checked.  Possible use cases are: 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion groups.  The stream only sends data to the robot controller if a motion is executed.  If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity.  2. Mimic Freedrive motions.  <!-- theme: danger -->  > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits.
+         * @summary Stream Joint Configuration
+         * @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 {ExternalJointStreamRequest} externalJointStreamRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        externalJointsStream(cell, controller, externalJointStreamRequest, options) {
+            return localVarFp.externalJointsStream(cell, controller, externalJointStreamRequest, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Get the cycle time of controller communication in [ms].
+         * @summary Get Cycle Time
+         * @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}
+         */
+        getCycleTime(cell, controller, options) {
+            return localVarFp.getCycleTime(cell, controller, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Get the current virtual controller behavior - please see the setter [setVirtualControllerBehavior](setVirtualControllerBehavior) and the enum for details.
+         * @summary Get Behavior
+         * @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}
+         */
+        getVirtualControllerBehavior(cell, controller, options) {
+            return localVarFp.getVirtualControllerBehavior(cell, controller, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Set virtual controller behavior.
+         * @summary Set Behavior
+         * @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 {Behavior} [behavior]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        setVirtualControllerBehavior(cell, controller, behavior, options) {
+            return localVarFp.setVirtualControllerBehavior(cell, controller, behavior, options).then((request) => request(axios, basePath));
+        },
+    };
+};
+/**
+ * VirtualControllerBehaviorApi - object-oriented interface
+ * @export
+ * @class VirtualControllerBehaviorApi
+ * @extends {BaseAPI}
+ */
+export class VirtualControllerBehaviorApi extends BaseAPI {
+    /**
+     * <!-- theme: danger -->  > Websocket endpoint  This stream sends the commanded state (joint positions, velocities, accelerations, torques) for each motion group of the virtual controller and sets the joint configuration. Moving motion groups on virtual controllers can be executed by using Trajectory Planning and Trajectory Execution. Trajectory Execution commands the desired joint configuration to each motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! > **NOTE** > > This stream provides *commanded* joint states, it **doesn\'t provide actual joint states**.  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configuration. > **CAUTION** > > Incoming joint configurations are not visualized and their velocity limits are not checked.  Possible use cases are: 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion groups.  The stream only sends data to the robot controller if a motion is executed.  If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity.  2. Mimic Freedrive motions.  <!-- theme: danger -->  > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits.
+     * @summary Stream Joint Configuration
+     * @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 {ExternalJointStreamRequest} externalJointStreamRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof VirtualControllerBehaviorApi
+     */
+    externalJointsStream(cell, controller, externalJointStreamRequest, options) {
+        return VirtualControllerBehaviorApiFp(this.configuration).externalJointsStream(cell, controller, externalJointStreamRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Get the cycle time of controller communication in [ms].
+     * @summary Get Cycle Time
+     * @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 VirtualControllerBehaviorApi
+     */
+    getCycleTime(cell, controller, options) {
+        return VirtualControllerBehaviorApiFp(this.configuration).getCycleTime(cell, controller, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Get the current virtual controller behavior - please see the setter [setVirtualControllerBehavior](setVirtualControllerBehavior) and the enum for details.
+     * @summary Get Behavior
+     * @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 VirtualControllerBehaviorApi
+     */
+    getVirtualControllerBehavior(cell, controller, options) {
+        return VirtualControllerBehaviorApiFp(this.configuration).getVirtualControllerBehavior(cell, controller, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Set virtual controller behavior.
+     * @summary Set Behavior
+     * @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 {Behavior} [behavior]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof VirtualControllerBehaviorApi
+     */
+    setVirtualControllerBehavior(cell, controller, behavior, options) {
+        return VirtualControllerBehaviorApiFp(this.configuration).setVirtualControllerBehavior(cell, controller, behavior, options).then((request) => request(this.axios, this.basePath));
+    }
+}
+/**
+ * VirtualControllerInputsOutputsApi - axios parameter creator
+ * @export
+ */
+export const VirtualControllerInputsOutputsApiAxiosParamCreator = function (configuration) {
+    return {
+        /**
+         * Retrieves the current values of inputs/outputs of the virtual controller.  The identifiers of inputs/outputs must be provided in the request. Request all available input/output identifiers via [listVirtualControllerIODescriptions](listVirtualControllerIODescriptions).
+         * @summary Get Input/Output Values
          * @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 {Array<string>} ios
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listVirtualRobotCoordinateSystems: async (cell, controller, options = {}) => {
+        listIOs: async (cell, controller, ios, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('listVirtualRobotCoordinateSystems', 'cell', cell);
+            assertParamExists('listIOs', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('listVirtualRobotCoordinateSystems', 'controller', controller);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/coordinate-systems`
+            assertParamExists('listIOs', 'controller', controller);
+            // verify required parameter 'ios' is not null or undefined
+            assertParamExists('listIOs', 'ios', ios);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/ios/values`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -8853,6 +9157,9 @@ export const VirtualRobotSetupApiAxiosParamCreator = function (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 };
@@ -8862,25 +9169,25 @@ export const VirtualRobotSetupApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Lists TCPs of the motion group. An empty TCP list is valid, for example for external axes.
-         * @summary List TCPs
+         * Lists the input/output descriptions of the virtual robot controller.  The input/output descriptions contain information like name, type and unit. Available inputs/outputs are defined by the virtual robot controller. Each input/output has a unique identifier. If no identifiers are specified in the request, all available inputs/outputs are retrieved by this endpoint. Exception: When a filter (e.g., direction, value_type, group) is applied, only matching inputs/outputs are returned.
+         * @summary List Descriptions
          * @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 {string} motionGroup The motion-group identifier.
+         * @param {Array<string>} [ios]
+         * @param {IODirection} [direction] Return only inputs/outputs with the specified direction.
+         * @param {IOValueType} [valueType] Return only inputs/outputs with the specified value type.
+         * @param {string} [group] Return only inputs/outputs from the specified group.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listVirtualRobotTcps: async (cell, controller, motionGroup, options = {}) => {
+        listVirtualControllerIODescriptions: async (cell, controller, ios, direction, valueType, group, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('listVirtualRobotTcps', 'cell', cell);
+            assertParamExists('listVirtualControllerIODescriptions', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('listVirtualRobotTcps', 'controller', controller);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('listVirtualRobotTcps', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/motion-groups/{motion-group}/tcps`
+            assertParamExists('listVirtualControllerIODescriptions', 'controller', controller);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/ios/description`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
+                .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;
@@ -8896,6 +9203,18 @@ export const VirtualRobotSetupApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            if (ios) {
+                localVarQueryParameter['ios'] = ios;
+            }
+            if (direction !== undefined) {
+                localVarQueryParameter['direction'] = direction;
+            }
+            if (valueType !== undefined) {
+                localVarQueryParameter['value_type'] = valueType;
+            }
+            if (group !== undefined) {
+                localVarQueryParameter['group'] = group;
+            }
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -8905,28 +9224,24 @@ export const VirtualRobotSetupApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Sets motion group mounting by specifying a coordinate system. The motion group will be based on the coordinate system\'s origin. The coordinate system defines a transformation offset. The transformation offset is defined by a unique identifier, a name for front end usage and an offset in another coordinate system referenced by the unique identifier of the reference coordinate system.
-         * @summary Set Mounting
+         * Sets a list of values of a virtual controller inputs/outputs.
+         * @summary Set Input/Ouput Values
          * @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 {string} motionGroup The motion-group identifier.
-         * @param {CoordinateSystem} coordinateSystem
+         * @param {Array<IOValue>} iOValue
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        setVirtualRobotMounting: async (cell, controller, motionGroup, coordinateSystem, options = {}) => {
+        setIOValues: async (cell, controller, iOValue, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('setVirtualRobotMounting', 'cell', cell);
+            assertParamExists('setIOValues', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('setVirtualRobotMounting', 'controller', controller);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('setVirtualRobotMounting', 'motionGroup', motionGroup);
-            // verify required parameter 'coordinateSystem' is not null or undefined
-            assertParamExists('setVirtualRobotMounting', 'coordinateSystem', coordinateSystem);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/teach-pendant/motion-groups/{motion-group}/mounting`
+            assertParamExists('setIOValues', 'controller', controller);
+            // verify required parameter 'iOValue' is not null or undefined
+            assertParamExists('setIOValues', 'iOValue', iOValue);
+            const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/ios/values`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
+                .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;
@@ -8946,7 +9261,7 @@ export const VirtualRobotSetupApiAxiosParamCreator = function (configuration) {
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            localVarRequestOptions.data = serializeDataIfNeeded(coordinateSystem, localVarRequestOptions, configuration);
+            localVarRequestOptions.data = serializeDataIfNeeded(iOValue, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
@@ -8955,358 +9270,158 @@ export const VirtualRobotSetupApiAxiosParamCreator = function (configuration) {
     };
 };
 /**
- * VirtualRobotSetupApi - functional programming interface
+ * VirtualControllerInputsOutputsApi - functional programming interface
  * @export
  */
-export const VirtualRobotSetupApiFp = function (configuration) {
-    const localVarAxiosParamCreator = VirtualRobotSetupApiAxiosParamCreator(configuration);
+export const VirtualControllerInputsOutputsApiFp = function (configuration) {
+    const localVarAxiosParamCreator = VirtualControllerInputsOutputsApiAxiosParamCreator(configuration);
     return {
         /**
-         * Adds a coordinate system to the robot controller.
-         * @summary Add Coordinate Systems
-         * @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 {CoordinateSystem} coordinateSystem
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async addVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.addVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotSetupApi.addVirtualRobotCoordinateSystem']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Adds a new TCP or updates an existing TCP in the motion group.  The position and rotation values in the request body are defined within the flange’s coordinate system.  > **NOTE** > > Ensure the TCP\'s position is within the robot\'s reach. Refer to the robot’s documentation or data sheet for details like joint limits or reach.
-         * @summary Add TCP
-         * @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 {string} motionGroup The motion-group identifier.
-         * @param {RobotTcp} robotTcp
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async addVirtualRobotTcp(cell, controller, motionGroup, robotTcp, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.addVirtualRobotTcp(cell, controller, motionGroup, robotTcp, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotSetupApi.addVirtualRobotTcp']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Deletes a coordinate system from the virtual controller. This will remove the coordinate system from the list of coordinate systems and remove all dependent coordinate systems which use the deleted coordinate system as reference.
-         * @summary Remove Coordinate System
-         * @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 {string} coordinateSystem Unique identifier addressing a coordinate system.
-         * @param {boolean} [deleteDependent] If true, all dependent coordinate systems will be deleted as well.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async deleteVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.deleteVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotSetupApi.deleteVirtualRobotCoordinateSystem']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Removes the TCP from the motion group. An unknown TCP is a valid input.
-         * @summary Remove TCP
-         * @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 {string} motionGroup The motion-group identifier.
-         * @param {string} tcp The unique identifier of a TCP.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async deleteVirtualRobotTcp(cell, controller, motionGroup, tcp, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.deleteVirtualRobotTcp(cell, controller, motionGroup, tcp, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotSetupApi.deleteVirtualRobotTcp']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Gets motion group mounting. The motion group is based on the origin of the returned coordinate system.
-         * @summary Get Mounting
-         * @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 {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getVirtualRobotMounting(cell, controller, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getVirtualRobotMounting(cell, controller, motionGroup, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotSetupApi.getVirtualRobotMounting']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Lists all coordinate systems on the robot controller.
-         * @summary List Coordinate Systems
+         * Retrieves the current values of inputs/outputs of the virtual controller.  The identifiers of inputs/outputs must be provided in the request. Request all available input/output identifiers via [listVirtualControllerIODescriptions](listVirtualControllerIODescriptions).
+         * @summary Get Input/Output Values
          * @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 {Array<string>} ios
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async listVirtualRobotCoordinateSystems(cell, controller, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listVirtualRobotCoordinateSystems(cell, controller, options);
+        async listIOs(cell, controller, ios, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listIOs(cell, controller, ios, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotSetupApi.listVirtualRobotCoordinateSystems']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerInputsOutputsApi.listIOs']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Lists TCPs of the motion group. An empty TCP list is valid, for example for external axes.
-         * @summary List TCPs
+         * Lists the input/output descriptions of the virtual robot controller.  The input/output descriptions contain information like name, type and unit. Available inputs/outputs are defined by the virtual robot controller. Each input/output has a unique identifier. If no identifiers are specified in the request, all available inputs/outputs are retrieved by this endpoint. Exception: When a filter (e.g., direction, value_type, group) is applied, only matching inputs/outputs are returned.
+         * @summary List Descriptions
          * @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 {string} motionGroup The motion-group identifier.
+         * @param {Array<string>} [ios]
+         * @param {IODirection} [direction] Return only inputs/outputs with the specified direction.
+         * @param {IOValueType} [valueType] Return only inputs/outputs with the specified value type.
+         * @param {string} [group] Return only inputs/outputs from the specified group.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async listVirtualRobotTcps(cell, controller, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listVirtualRobotTcps(cell, controller, motionGroup, options);
+        async listVirtualControllerIODescriptions(cell, controller, ios, direction, valueType, group, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listVirtualControllerIODescriptions(cell, controller, ios, direction, valueType, group, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotSetupApi.listVirtualRobotTcps']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerInputsOutputsApi.listVirtualControllerIODescriptions']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Sets motion group mounting by specifying a coordinate system. The motion group will be based on the coordinate system\'s origin. The coordinate system defines a transformation offset. The transformation offset is defined by a unique identifier, a name for front end usage and an offset in another coordinate system referenced by the unique identifier of the reference coordinate system.
-         * @summary Set Mounting
+         * Sets a list of values of a virtual controller inputs/outputs.
+         * @summary Set Input/Ouput Values
          * @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 {string} motionGroup The motion-group identifier.
-         * @param {CoordinateSystem} coordinateSystem
+         * @param {Array<IOValue>} iOValue
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async setVirtualRobotMounting(cell, controller, motionGroup, coordinateSystem, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.setVirtualRobotMounting(cell, controller, motionGroup, coordinateSystem, options);
+        async setIOValues(cell, controller, iOValue, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.setIOValues(cell, controller, iOValue, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualRobotSetupApi.setVirtualRobotMounting']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerInputsOutputsApi.setIOValues']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     };
 };
 /**
- * VirtualRobotSetupApi - factory interface
+ * VirtualControllerInputsOutputsApi - factory interface
  * @export
  */
-export const VirtualRobotSetupApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = VirtualRobotSetupApiFp(configuration);
+export const VirtualControllerInputsOutputsApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = VirtualControllerInputsOutputsApiFp(configuration);
     return {
         /**
-         * Adds a coordinate system to the robot controller.
-         * @summary Add Coordinate Systems
-         * @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 {CoordinateSystem} coordinateSystem
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        addVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, options) {
-            return localVarFp.addVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Adds a new TCP or updates an existing TCP in the motion group.  The position and rotation values in the request body are defined within the flange’s coordinate system.  > **NOTE** > > Ensure the TCP\'s position is within the robot\'s reach. Refer to the robot’s documentation or data sheet for details like joint limits or reach.
-         * @summary Add TCP
-         * @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 {string} motionGroup The motion-group identifier.
-         * @param {RobotTcp} robotTcp
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        addVirtualRobotTcp(cell, controller, motionGroup, robotTcp, options) {
-            return localVarFp.addVirtualRobotTcp(cell, controller, motionGroup, robotTcp, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Deletes a coordinate system from the virtual controller. This will remove the coordinate system from the list of coordinate systems and remove all dependent coordinate systems which use the deleted coordinate system as reference.
-         * @summary Remove Coordinate System
-         * @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 {string} coordinateSystem Unique identifier addressing a coordinate system.
-         * @param {boolean} [deleteDependent] If true, all dependent coordinate systems will be deleted as well.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        deleteVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options) {
-            return localVarFp.deleteVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Removes the TCP from the motion group. An unknown TCP is a valid input.
-         * @summary Remove TCP
-         * @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 {string} motionGroup The motion-group identifier.
-         * @param {string} tcp The unique identifier of a TCP.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        deleteVirtualRobotTcp(cell, controller, motionGroup, tcp, options) {
-            return localVarFp.deleteVirtualRobotTcp(cell, controller, motionGroup, tcp, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Gets motion group mounting. The motion group is based on the origin of the returned coordinate system.
-         * @summary Get Mounting
-         * @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 {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getVirtualRobotMounting(cell, controller, motionGroup, options) {
-            return localVarFp.getVirtualRobotMounting(cell, controller, motionGroup, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Lists all coordinate systems on the robot controller.
-         * @summary List Coordinate Systems
+         * Retrieves the current values of inputs/outputs of the virtual controller.  The identifiers of inputs/outputs must be provided in the request. Request all available input/output identifiers via [listVirtualControllerIODescriptions](listVirtualControllerIODescriptions).
+         * @summary Get Input/Output Values
          * @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 {Array<string>} ios
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listVirtualRobotCoordinateSystems(cell, controller, options) {
-            return localVarFp.listVirtualRobotCoordinateSystems(cell, controller, options).then((request) => request(axios, basePath));
+        listIOs(cell, controller, ios, options) {
+            return localVarFp.listIOs(cell, controller, ios, options).then((request) => request(axios, basePath));
         },
         /**
-         * Lists TCPs of the motion group. An empty TCP list is valid, for example for external axes.
-         * @summary List TCPs
+         * Lists the input/output descriptions of the virtual robot controller.  The input/output descriptions contain information like name, type and unit. Available inputs/outputs are defined by the virtual robot controller. Each input/output has a unique identifier. If no identifiers are specified in the request, all available inputs/outputs are retrieved by this endpoint. Exception: When a filter (e.g., direction, value_type, group) is applied, only matching inputs/outputs are returned.
+         * @summary List Descriptions
          * @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 {string} motionGroup The motion-group identifier.
+         * @param {Array<string>} [ios]
+         * @param {IODirection} [direction] Return only inputs/outputs with the specified direction.
+         * @param {IOValueType} [valueType] Return only inputs/outputs with the specified value type.
+         * @param {string} [group] Return only inputs/outputs from the specified group.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listVirtualRobotTcps(cell, controller, motionGroup, options) {
-            return localVarFp.listVirtualRobotTcps(cell, controller, motionGroup, options).then((request) => request(axios, basePath));
+        listVirtualControllerIODescriptions(cell, controller, ios, direction, valueType, group, options) {
+            return localVarFp.listVirtualControllerIODescriptions(cell, controller, ios, direction, valueType, group, options).then((request) => request(axios, basePath));
         },
         /**
-         * Sets motion group mounting by specifying a coordinate system. The motion group will be based on the coordinate system\'s origin. The coordinate system defines a transformation offset. The transformation offset is defined by a unique identifier, a name for front end usage and an offset in another coordinate system referenced by the unique identifier of the reference coordinate system.
-         * @summary Set Mounting
+         * Sets a list of values of a virtual controller inputs/outputs.
+         * @summary Set Input/Ouput Values
          * @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 {string} motionGroup The motion-group identifier.
-         * @param {CoordinateSystem} coordinateSystem
+         * @param {Array<IOValue>} iOValue
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        setVirtualRobotMounting(cell, controller, motionGroup, coordinateSystem, options) {
-            return localVarFp.setVirtualRobotMounting(cell, controller, motionGroup, coordinateSystem, options).then((request) => request(axios, basePath));
+        setIOValues(cell, controller, iOValue, options) {
+            return localVarFp.setIOValues(cell, controller, iOValue, options).then((request) => request(axios, basePath));
         },
     };
 };
 /**
- * VirtualRobotSetupApi - object-oriented interface
+ * VirtualControllerInputsOutputsApi - object-oriented interface
  * @export
- * @class VirtualRobotSetupApi
+ * @class VirtualControllerInputsOutputsApi
  * @extends {BaseAPI}
  */
-export class VirtualRobotSetupApi extends BaseAPI {
-    /**
-     * Adds a coordinate system to the robot controller.
-     * @summary Add Coordinate Systems
-     * @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 {CoordinateSystem} coordinateSystem
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof VirtualRobotSetupApi
-     */
-    addVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, options) {
-        return VirtualRobotSetupApiFp(this.configuration).addVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, options).then((request) => request(this.axios, this.basePath));
-    }
+export class VirtualControllerInputsOutputsApi extends BaseAPI {
     /**
-     * Adds a new TCP or updates an existing TCP in the motion group.  The position and rotation values in the request body are defined within the flange’s coordinate system.  > **NOTE** > > Ensure the TCP\'s position is within the robot\'s reach. Refer to the robot’s documentation or data sheet for details like joint limits or reach.
-     * @summary Add TCP
-     * @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 {string} motionGroup The motion-group identifier.
-     * @param {RobotTcp} robotTcp
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof VirtualRobotSetupApi
-     */
-    addVirtualRobotTcp(cell, controller, motionGroup, robotTcp, options) {
-        return VirtualRobotSetupApiFp(this.configuration).addVirtualRobotTcp(cell, controller, motionGroup, robotTcp, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Deletes a coordinate system from the virtual controller. This will remove the coordinate system from the list of coordinate systems and remove all dependent coordinate systems which use the deleted coordinate system as reference.
-     * @summary Remove Coordinate System
-     * @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 {string} coordinateSystem Unique identifier addressing a coordinate system.
-     * @param {boolean} [deleteDependent] If true, all dependent coordinate systems will be deleted as well.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof VirtualRobotSetupApi
-     */
-    deleteVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options) {
-        return VirtualRobotSetupApiFp(this.configuration).deleteVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Removes the TCP from the motion group. An unknown TCP is a valid input.
-     * @summary Remove TCP
-     * @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 {string} motionGroup The motion-group identifier.
-     * @param {string} tcp The unique identifier of a TCP.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof VirtualRobotSetupApi
-     */
-    deleteVirtualRobotTcp(cell, controller, motionGroup, tcp, options) {
-        return VirtualRobotSetupApiFp(this.configuration).deleteVirtualRobotTcp(cell, controller, motionGroup, tcp, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Gets motion group mounting. The motion group is based on the origin of the returned coordinate system.
-     * @summary Get Mounting
-     * @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 {string} motionGroup The motion-group identifier.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof VirtualRobotSetupApi
-     */
-    getVirtualRobotMounting(cell, controller, motionGroup, options) {
-        return VirtualRobotSetupApiFp(this.configuration).getVirtualRobotMounting(cell, controller, motionGroup, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Lists all coordinate systems on the robot controller.
-     * @summary List Coordinate Systems
+     * Retrieves the current values of inputs/outputs of the virtual controller.  The identifiers of inputs/outputs must be provided in the request. Request all available input/output identifiers via [listVirtualControllerIODescriptions](listVirtualControllerIODescriptions).
+     * @summary Get Input/Output Values
      * @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 {Array<string>} ios
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof VirtualRobotSetupApi
+     * @memberof VirtualControllerInputsOutputsApi
      */
-    listVirtualRobotCoordinateSystems(cell, controller, options) {
-        return VirtualRobotSetupApiFp(this.configuration).listVirtualRobotCoordinateSystems(cell, controller, options).then((request) => request(this.axios, this.basePath));
+    listIOs(cell, controller, ios, options) {
+        return VirtualControllerInputsOutputsApiFp(this.configuration).listIOs(cell, controller, ios, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Lists TCPs of the motion group. An empty TCP list is valid, for example for external axes.
-     * @summary List TCPs
+     * Lists the input/output descriptions of the virtual robot controller.  The input/output descriptions contain information like name, type and unit. Available inputs/outputs are defined by the virtual robot controller. Each input/output has a unique identifier. If no identifiers are specified in the request, all available inputs/outputs are retrieved by this endpoint. Exception: When a filter (e.g., direction, value_type, group) is applied, only matching inputs/outputs are returned.
+     * @summary List Descriptions
      * @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 {string} motionGroup The motion-group identifier.
+     * @param {Array<string>} [ios]
+     * @param {IODirection} [direction] Return only inputs/outputs with the specified direction.
+     * @param {IOValueType} [valueType] Return only inputs/outputs with the specified value type.
+     * @param {string} [group] Return only inputs/outputs from the specified group.
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof VirtualRobotSetupApi
+     * @memberof VirtualControllerInputsOutputsApi
      */
-    listVirtualRobotTcps(cell, controller, motionGroup, options) {
-        return VirtualRobotSetupApiFp(this.configuration).listVirtualRobotTcps(cell, controller, motionGroup, options).then((request) => request(this.axios, this.basePath));
+    listVirtualControllerIODescriptions(cell, controller, ios, direction, valueType, group, options) {
+        return VirtualControllerInputsOutputsApiFp(this.configuration).listVirtualControllerIODescriptions(cell, controller, ios, direction, valueType, group, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Sets motion group mounting by specifying a coordinate system. The motion group will be based on the coordinate system\'s origin. The coordinate system defines a transformation offset. The transformation offset is defined by a unique identifier, a name for front end usage and an offset in another coordinate system referenced by the unique identifier of the reference coordinate system.
-     * @summary Set Mounting
+     * Sets a list of values of a virtual controller inputs/outputs.
+     * @summary Set Input/Ouput Values
      * @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 {string} motionGroup The motion-group identifier.
-     * @param {CoordinateSystem} coordinateSystem
+     * @param {Array<IOValue>} iOValue
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof VirtualRobotSetupApi
+     * @memberof VirtualControllerInputsOutputsApi
      */
-    setVirtualRobotMounting(cell, controller, motionGroup, coordinateSystem, options) {
-        return VirtualRobotSetupApiFp(this.configuration).setVirtualRobotMounting(cell, controller, motionGroup, coordinateSystem, options).then((request) => request(this.axios, this.basePath));
+    setIOValues(cell, controller, iOValue, options) {
+        return VirtualControllerInputsOutputsApiFp(this.configuration).setIOValues(cell, controller, iOValue, options).then((request) => request(this.axios, this.basePath));
     }
 }
 //# sourceMappingURL=api.js.map