@wandelbots/nova-api 25.7.0-dev.18 → 25.7.0-dev.3

package/v2/api.js

@@ -86,6 +86,9 @@ export const Direction = {
     DirectionForward: 'DIRECTION_FORWARD',
     DirectionBackward: 'DIRECTION_BACKWARD'
 };
+export const EndOfTrajectoryKindEnum = {
+    EndOfTrajectory: 'END_OF_TRAJECTORY'
+};
 export const FanucControllerKindEnum = {
     FanucController: 'FanucController'
 };
@@ -150,21 +153,6 @@ 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'
 };
@@ -287,6 +275,21 @@ 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'
 };
@@ -323,6 +326,12 @@ 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
@@ -428,24 +437,9 @@ 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
@@ -583,6 +577,9 @@ export const VirtualControllerTypes = {
     YaskawaHc10dtp: 'yaskawa-hc10dtp',
     YaskawaHc20dtp: 'yaskawa-hc20dtp'
 };
+export const WaitForIOKindEnum = {
+    WaitForIo: 'WAIT_FOR_IO'
+};
 export const YaskawaControllerKindEnum = {
     YaskawaController: 'YaskawaController'
 };
@@ -1780,45 +1777,6 @@ 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
@@ -1984,18 +1942,18 @@ export const ControllerApiAxiosParamCreator = function (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
+         * 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
          * @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}
          */
-        getVirtualControllerConfiguration: async (cell, controller, options = {}) => {
+        getVirtualRobotConfiguration: async (cell, controller, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getVirtualControllerConfiguration', 'cell', cell);
+            assertParamExists('getVirtualRobotConfiguration', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getVirtualControllerConfiguration', 'controller', controller);
+            assertParamExists('getVirtualRobotConfiguration', 'controller', controller);
             const localVarPath = `/cells/{cell}/controllers/{controller}/virtual-robot-configuration`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
@@ -2332,20 +2290,6 @@ 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
@@ -2405,17 +2349,17 @@ export const ControllerApiFp = function (configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * 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
+         * 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
          * @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 getVirtualControllerConfiguration(cell, controller, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getVirtualControllerConfiguration(cell, controller, options);
+        async getVirtualRobotConfiguration(cell, controller, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getVirtualRobotConfiguration(cell, controller, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ControllerApi.getVirtualControllerConfiguration']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['ControllerApi.getVirtualRobotConfiguration']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -2551,17 +2495,6 @@ 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
@@ -2609,15 +2542,15 @@ export const ControllerApiFactory = function (configuration, basePath, axios) {
             return localVarFp.getRobotController(cell, controller, options).then((request) => request(axios, basePath));
         },
         /**
-         * 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
+         * 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
          * @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}
          */
-        getVirtualControllerConfiguration(cell, controller, options) {
-            return localVarFp.getVirtualControllerConfiguration(cell, controller, options).then((request) => request(axios, basePath));
+        getVirtualRobotConfiguration(cell, controller, options) {
+            return localVarFp.getVirtualRobotConfiguration(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.
@@ -2737,18 +2670,6 @@ 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
@@ -2800,16 +2721,16 @@ export class ControllerApi extends BaseAPI {
         return ControllerApiFp(this.configuration).getRobotController(cell, controller, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * 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
+     * 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
      * @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
      */
-    getVirtualControllerConfiguration(cell, controller, options) {
-        return ControllerApiFp(this.configuration).getVirtualControllerConfiguration(cell, controller, options).then((request) => request(this.axios, this.basePath));
+    getVirtualRobotConfiguration(cell, controller, options) {
+        return ControllerApiFp(this.configuration).getVirtualRobotConfiguration(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.
@@ -7474,15 +7395,15 @@ export const VirtualControllerApiAxiosParamCreator = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        addVirtualControllerCoordinateSystem: async (cell, controller, coordinateSystem, coordinateSystemData, options = {}) => {
+        addVirtualRobotCoordinateSystem: async (cell, controller, coordinateSystem, coordinateSystemData, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('addVirtualControllerCoordinateSystem', 'cell', cell);
+            assertParamExists('addVirtualRobotCoordinateSystem', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('addVirtualControllerCoordinateSystem', 'controller', controller);
+            assertParamExists('addVirtualRobotCoordinateSystem', 'controller', controller);
             // verify required parameter 'coordinateSystem' is not null or undefined
-            assertParamExists('addVirtualControllerCoordinateSystem', 'coordinateSystem', coordinateSystem);
+            assertParamExists('addVirtualRobotCoordinateSystem', 'coordinateSystem', coordinateSystem);
             // verify required parameter 'coordinateSystemData' is not null or undefined
-            assertParamExists('addVirtualControllerCoordinateSystem', 'coordinateSystemData', coordinateSystemData);
+            assertParamExists('addVirtualRobotCoordinateSystem', 'coordinateSystemData', coordinateSystemData);
             const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/coordinate-systems/{coordinate-system}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
@@ -7523,17 +7444,17 @@ export const VirtualControllerApiAxiosParamCreator = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        addVirtualControllerTcp: async (cell, controller, motionGroup, tcp, robotTcpData, options = {}) => {
+        addVirtualRobotTcp: async (cell, controller, motionGroup, tcp, robotTcpData, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('addVirtualControllerTcp', 'cell', cell);
+            assertParamExists('addVirtualRobotTcp', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('addVirtualControllerTcp', 'controller', controller);
+            assertParamExists('addVirtualRobotTcp', 'controller', controller);
             // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('addVirtualControllerTcp', 'motionGroup', motionGroup);
+            assertParamExists('addVirtualRobotTcp', 'motionGroup', motionGroup);
             // verify required parameter 'tcp' is not null or undefined
-            assertParamExists('addVirtualControllerTcp', 'tcp', tcp);
+            assertParamExists('addVirtualRobotTcp', 'tcp', tcp);
             // verify required parameter 'robotTcpData' is not null or undefined
-            assertParamExists('addVirtualControllerTcp', 'robotTcpData', robotTcpData);
+            assertParamExists('addVirtualRobotTcp', '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)))
@@ -7574,13 +7495,13 @@ export const VirtualControllerApiAxiosParamCreator = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        deleteVirtualControllerCoordinateSystem: async (cell, controller, coordinateSystem, deleteDependent, options = {}) => {
+        deleteVirtualRobotCoordinateSystem: async (cell, controller, coordinateSystem, deleteDependent, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('deleteVirtualControllerCoordinateSystem', 'cell', cell);
+            assertParamExists('deleteVirtualRobotCoordinateSystem', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('deleteVirtualControllerCoordinateSystem', 'controller', controller);
+            assertParamExists('deleteVirtualRobotCoordinateSystem', 'controller', controller);
             // verify required parameter 'coordinateSystem' is not null or undefined
-            assertParamExists('deleteVirtualControllerCoordinateSystem', 'coordinateSystem', coordinateSystem);
+            assertParamExists('deleteVirtualRobotCoordinateSystem', 'coordinateSystem', coordinateSystem);
             const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/coordinate-systems/{coordinate-system}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
@@ -7621,15 +7542,15 @@ export const VirtualControllerApiAxiosParamCreator = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        deleteVirtualControllerTcp: async (cell, controller, motionGroup, tcp, options = {}) => {
+        deleteVirtualRobotTcp: async (cell, controller, motionGroup, tcp, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('deleteVirtualControllerTcp', 'cell', cell);
+            assertParamExists('deleteVirtualRobotTcp', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('deleteVirtualControllerTcp', 'controller', controller);
+            assertParamExists('deleteVirtualRobotTcp', 'controller', controller);
             // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('deleteVirtualControllerTcp', 'motionGroup', motionGroup);
+            assertParamExists('deleteVirtualRobotTcp', 'motionGroup', motionGroup);
             // verify required parameter 'tcp' is not null or undefined
-            assertParamExists('deleteVirtualControllerTcp', 'tcp', tcp);
+            assertParamExists('deleteVirtualRobotTcp', '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)))
@@ -7827,13 +7748,13 @@ export const VirtualControllerApiAxiosParamCreator = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getVirtualControllerMounting: async (cell, controller, motionGroup, options = {}) => {
+        getVirtualRobotMounting: async (cell, controller, motionGroup, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getVirtualControllerMounting', 'cell', cell);
+            assertParamExists('getVirtualRobotMounting', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getVirtualControllerMounting', 'controller', controller);
+            assertParamExists('getVirtualRobotMounting', 'controller', controller);
             // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('getVirtualControllerMounting', 'motionGroup', motionGroup);
+            assertParamExists('getVirtualRobotMounting', 'motionGroup', motionGroup);
             const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/motion-groups/{motion-group}/mounting`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
@@ -7869,11 +7790,11 @@ export const VirtualControllerApiAxiosParamCreator = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listVirtualControllerCoordinateSystems: async (cell, controller, options = {}) => {
+        listVirtualRobotCoordinateSystems: async (cell, controller, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('listVirtualControllerCoordinateSystems', 'cell', cell);
+            assertParamExists('listVirtualRobotCoordinateSystems', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('listVirtualControllerCoordinateSystems', 'controller', controller);
+            assertParamExists('listVirtualRobotCoordinateSystems', 'controller', controller);
             const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/coordinate-systems`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
@@ -7909,13 +7830,13 @@ export const VirtualControllerApiAxiosParamCreator = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listVirtualControllerTcps: async (cell, controller, motionGroup, options = {}) => {
+        listVirtualRobotTcps: async (cell, controller, motionGroup, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('listVirtualControllerTcps', 'cell', cell);
+            assertParamExists('listVirtualRobotTcps', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('listVirtualControllerTcps', 'controller', controller);
+            assertParamExists('listVirtualRobotTcps', 'controller', controller);
             // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('listVirtualControllerTcps', 'motionGroup', motionGroup);
+            assertParamExists('listVirtualRobotTcps', 'motionGroup', motionGroup);
             const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/motion-groups/{motion-group}/tcps`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
@@ -8089,15 +8010,15 @@ export const VirtualControllerApiAxiosParamCreator = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        setVirtualControllerMounting: async (cell, controller, motionGroup, coordinateSystem, options = {}) => {
+        setVirtualRobotMounting: async (cell, controller, motionGroup, coordinateSystem, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('setVirtualControllerMounting', 'cell', cell);
+            assertParamExists('setVirtualRobotMounting', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('setVirtualControllerMounting', 'controller', controller);
+            assertParamExists('setVirtualRobotMounting', 'controller', controller);
             // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('setVirtualControllerMounting', 'motionGroup', motionGroup);
+            assertParamExists('setVirtualRobotMounting', 'motionGroup', motionGroup);
             // verify required parameter 'coordinateSystem' is not null or undefined
-            assertParamExists('setVirtualControllerMounting', 'coordinateSystem', coordinateSystem);
+            assertParamExists('setVirtualRobotMounting', 'coordinateSystem', coordinateSystem);
             const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/motion-groups/{motion-group}/mounting`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
@@ -8146,10 +8067,10 @@ export const VirtualControllerApiFp = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async addVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.addVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options);
+        async addVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.addVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.addVirtualControllerCoordinateSystem']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.addVirtualRobotCoordinateSystem']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -8163,10 +8084,10 @@ export const VirtualControllerApiFp = function (configuration) {
          * @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);
+        async addVirtualRobotTcp(cell, controller, motionGroup, tcp, robotTcpData, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.addVirtualRobotTcp(cell, controller, motionGroup, tcp, robotTcpData, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.addVirtualControllerTcp']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.addVirtualRobotTcp']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -8179,10 +8100,10 @@ export const VirtualControllerApiFp = function (configuration) {
          * @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);
+        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['VirtualControllerApi.deleteVirtualControllerCoordinateSystem']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.deleteVirtualRobotCoordinateSystem']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -8195,10 +8116,10 @@ export const VirtualControllerApiFp = function (configuration) {
          * @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);
+        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['VirtualControllerApi.deleteVirtualControllerTcp']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.deleteVirtualRobotTcp']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -8267,10 +8188,10 @@ export const VirtualControllerApiFp = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async getVirtualControllerMounting(cell, controller, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getVirtualControllerMounting(cell, controller, motionGroup, options);
+        async getVirtualRobotMounting(cell, controller, motionGroup, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getVirtualRobotMounting(cell, controller, motionGroup, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.getVirtualControllerMounting']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.getVirtualRobotMounting']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -8281,10 +8202,10 @@ export const VirtualControllerApiFp = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async listVirtualControllerCoordinateSystems(cell, controller, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listVirtualControllerCoordinateSystems(cell, controller, options);
+        async listVirtualRobotCoordinateSystems(cell, controller, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listVirtualRobotCoordinateSystems(cell, controller, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.listVirtualControllerCoordinateSystems']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.listVirtualRobotCoordinateSystems']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -8296,10 +8217,10 @@ export const VirtualControllerApiFp = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async listVirtualControllerTcps(cell, controller, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listVirtualControllerTcps(cell, controller, motionGroup, options);
+        async listVirtualRobotTcps(cell, controller, motionGroup, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listVirtualRobotTcps(cell, controller, motionGroup, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.listVirtualControllerTcps']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.listVirtualRobotTcps']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -8358,10 +8279,10 @@ export const VirtualControllerApiFp = function (configuration) {
          * @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);
+        async setVirtualRobotMounting(cell, controller, motionGroup, coordinateSystem, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.setVirtualRobotMounting(cell, controller, motionGroup, coordinateSystem, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.setVirtualControllerMounting']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerApi.setVirtualRobotMounting']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     };
@@ -8383,8 +8304,8 @@ export const VirtualControllerApiFactory = function (configuration, basePath, ax
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        addVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options) {
-            return localVarFp.addVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options).then((request) => request(axios, basePath));
+        addVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options) {
+            return localVarFp.addVirtualRobotCoordinateSystem(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.
@@ -8397,8 +8318,8 @@ export const VirtualControllerApiFactory = function (configuration, basePath, ax
          * @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));
+        addVirtualRobotTcp(cell, controller, motionGroup, tcp, robotTcpData, options) {
+            return localVarFp.addVirtualRobotTcp(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.
@@ -8410,8 +8331,8 @@ export const VirtualControllerApiFactory = function (configuration, basePath, ax
          * @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));
+        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.
@@ -8423,8 +8344,8 @@ export const VirtualControllerApiFactory = function (configuration, basePath, ax
          * @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));
+        deleteVirtualRobotTcp(cell, controller, motionGroup, tcp, options) {
+            return localVarFp.deleteVirtualRobotTcp(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,8 +8401,8 @@ export const VirtualControllerApiFactory = function (configuration, basePath, ax
          * @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));
+        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.
@@ -8491,8 +8412,8 @@ export const VirtualControllerApiFactory = function (configuration, basePath, ax
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listVirtualControllerCoordinateSystems(cell, controller, options) {
-            return localVarFp.listVirtualControllerCoordinateSystems(cell, controller, options).then((request) => request(axios, basePath));
+        listVirtualRobotCoordinateSystems(cell, controller, options) {
+            return localVarFp.listVirtualRobotCoordinateSystems(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.
@@ -8503,8 +8424,8 @@ export const VirtualControllerApiFactory = function (configuration, basePath, ax
          * @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));
+        listVirtualRobotTcps(cell, controller, motionGroup, options) {
+            return localVarFp.listVirtualRobotTcps(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.
@@ -8553,8 +8474,8 @@ export const VirtualControllerApiFactory = function (configuration, basePath, ax
          * @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));
+        setVirtualRobotMounting(cell, controller, motionGroup, coordinateSystem, options) {
+            return localVarFp.setVirtualRobotMounting(cell, controller, motionGroup, coordinateSystem, options).then((request) => request(axios, basePath));
         },
     };
 };
@@ -8576,8 +8497,8 @@ export class VirtualControllerApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof VirtualControllerApi
      */
-    addVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options) {
-        return VirtualControllerApiFp(this.configuration).addVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options).then((request) => request(this.axios, this.basePath));
+    addVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options) {
+        return VirtualControllerApiFp(this.configuration).addVirtualRobotCoordinateSystem(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.
@@ -8591,8 +8512,8 @@ export class VirtualControllerApi extends BaseAPI {
      * @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));
+    addVirtualRobotTcp(cell, controller, motionGroup, tcp, robotTcpData, options) {
+        return VirtualControllerApiFp(this.configuration).addVirtualRobotTcp(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.
@@ -8605,8 +8526,8 @@ export class VirtualControllerApi extends BaseAPI {
      * @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));
+    deleteVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options) {
+        return VirtualControllerApiFp(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.
@@ -8619,8 +8540,8 @@ export class VirtualControllerApi extends BaseAPI {
      * @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));
+    deleteVirtualRobotTcp(cell, controller, motionGroup, tcp, options) {
+        return VirtualControllerApiFp(this.configuration).deleteVirtualRobotTcp(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.
@@ -8681,8 +8602,8 @@ export class VirtualControllerApi extends BaseAPI {
      * @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));
+    getVirtualRobotMounting(cell, controller, motionGroup, options) {
+        return VirtualControllerApiFp(this.configuration).getVirtualRobotMounting(cell, controller, motionGroup, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * Lists all coordinate systems on the robot controller.
@@ -8693,8 +8614,8 @@ export class VirtualControllerApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof VirtualControllerApi
      */
-    listVirtualControllerCoordinateSystems(cell, controller, options) {
-        return VirtualControllerApiFp(this.configuration).listVirtualControllerCoordinateSystems(cell, controller, options).then((request) => request(this.axios, this.basePath));
+    listVirtualRobotCoordinateSystems(cell, controller, options) {
+        return VirtualControllerApiFp(this.configuration).listVirtualRobotCoordinateSystems(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.
@@ -8706,8 +8627,8 @@ export class VirtualControllerApi extends BaseAPI {
      * @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));
+    listVirtualRobotTcps(cell, controller, motionGroup, options) {
+        return VirtualControllerApiFp(this.configuration).listVirtualRobotTcps(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.
@@ -8760,8 +8681,8 @@ export class VirtualControllerApi extends BaseAPI {
      * @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));
+    setVirtualRobotMounting(cell, controller, motionGroup, coordinateSystem, options) {
+        return VirtualControllerApiFp(this.configuration).setVirtualRobotMounting(cell, controller, motionGroup, coordinateSystem, options).then((request) => request(this.axios, this.basePath));
     }
 }
 /**
@@ -8854,18 +8775,18 @@ export const VirtualControllerBehaviorApiAxiosParamCreator = function (configura
             };
         },
         /**
-         * Get the current virtual controller behavior - please see the setter [setVirtualControllerBehavior](setVirtualControllerBehavior) and the enum for details.
+         * Get the current virtual controller behavior - please see the setter [setVirtualRobotBehavior](setVirtualRobotBehavior) 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: async (cell, controller, options = {}) => {
+        getVirtualRobotBehavior: async (cell, controller, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getVirtualControllerBehavior', 'cell', cell);
+            assertParamExists('getVirtualRobotBehavior', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getVirtualControllerBehavior', 'controller', controller);
+            assertParamExists('getVirtualRobotBehavior', 'controller', controller);
             const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/behavior`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
@@ -8901,11 +8822,11 @@ export const VirtualControllerBehaviorApiAxiosParamCreator = function (configura
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        setVirtualControllerBehavior: async (cell, controller, behavior, options = {}) => {
+        setVirtualRobotBehavior: async (cell, controller, behavior, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('setVirtualControllerBehavior', 'cell', cell);
+            assertParamExists('setVirtualRobotBehavior', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('setVirtualControllerBehavior', 'controller', controller);
+            assertParamExists('setVirtualRobotBehavior', 'controller', controller);
             const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/behavior`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
@@ -8974,17 +8895,17 @@ export const VirtualControllerBehaviorApiFp = function (configuration) {
             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.
+         * Get the current virtual controller behavior - please see the setter [setVirtualRobotBehavior](setVirtualRobotBehavior) 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);
+        async getVirtualRobotBehavior(cell, controller, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getVirtualRobotBehavior(cell, controller, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualControllerBehaviorApi.getVirtualControllerBehavior']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerBehaviorApi.getVirtualRobotBehavior']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -8996,10 +8917,10 @@ export const VirtualControllerBehaviorApiFp = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async setVirtualControllerBehavior(cell, controller, behavior, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.setVirtualControllerBehavior(cell, controller, behavior, options);
+        async setVirtualRobotBehavior(cell, controller, behavior, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.setVirtualRobotBehavior(cell, controller, behavior, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['VirtualControllerBehaviorApi.setVirtualControllerBehavior']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerBehaviorApi.setVirtualRobotBehavior']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     };
@@ -9035,15 +8956,15 @@ export const VirtualControllerBehaviorApiFactory = function (configuration, base
             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.
+         * Get the current virtual controller behavior - please see the setter [setVirtualRobotBehavior](setVirtualRobotBehavior) 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));
+        getVirtualRobotBehavior(cell, controller, options) {
+            return localVarFp.getVirtualRobotBehavior(cell, controller, options).then((request) => request(axios, basePath));
         },
         /**
          * Set virtual controller behavior.
@@ -9054,8 +8975,8 @@ export const VirtualControllerBehaviorApiFactory = function (configuration, base
          * @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));
+        setVirtualRobotBehavior(cell, controller, behavior, options) {
+            return localVarFp.setVirtualRobotBehavior(cell, controller, behavior, options).then((request) => request(axios, basePath));
         },
     };
 };
@@ -9092,7 +9013,7 @@ export class VirtualControllerBehaviorApi extends BaseAPI {
         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.
+     * Get the current virtual controller behavior - please see the setter [setVirtualRobotBehavior](setVirtualRobotBehavior) 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.
@@ -9100,8 +9021,8 @@ export class VirtualControllerBehaviorApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof VirtualControllerBehaviorApi
      */
-    getVirtualControllerBehavior(cell, controller, options) {
-        return VirtualControllerBehaviorApiFp(this.configuration).getVirtualControllerBehavior(cell, controller, options).then((request) => request(this.axios, this.basePath));
+    getVirtualRobotBehavior(cell, controller, options) {
+        return VirtualControllerBehaviorApiFp(this.configuration).getVirtualRobotBehavior(cell, controller, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * Set virtual controller behavior.
@@ -9113,8 +9034,8 @@ export class VirtualControllerBehaviorApi extends BaseAPI {
      * @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));
+    setVirtualRobotBehavior(cell, controller, behavior, options) {
+        return VirtualControllerBehaviorApiFp(this.configuration).setVirtualRobotBehavior(cell, controller, behavior, options).then((request) => request(this.axios, this.basePath));
     }
 }
 /**
@@ -9124,7 +9045,7 @@ export class VirtualControllerBehaviorApi extends BaseAPI {
 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).
+         * 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 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.
@@ -9180,11 +9101,11 @@ export const VirtualControllerInputsOutputsApiAxiosParamCreator = function (conf
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listVirtualControllerIODescriptions: async (cell, controller, ios, direction, valueType, group, options = {}) => {
+        listVirtualRobotIODescriptions: async (cell, controller, ios, direction, valueType, group, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('listVirtualControllerIODescriptions', 'cell', cell);
+            assertParamExists('listVirtualRobotIODescriptions', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('listVirtualControllerIODescriptions', 'controller', controller);
+            assertParamExists('listVirtualRobotIODescriptions', 'controller', controller);
             const localVarPath = `/cells/{cell}/virtual-controllers/{controller}/ios/description`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
@@ -9277,7 +9198,7 @@ export const VirtualControllerInputsOutputsApiFp = function (configuration) {
     const localVarAxiosParamCreator = VirtualControllerInputsOutputsApiAxiosParamCreator(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).
+         * 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 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.
@@ -9303,10 +9224,10 @@ export const VirtualControllerInputsOutputsApiFp = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async listVirtualControllerIODescriptions(cell, controller, ios, direction, valueType, group, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listVirtualControllerIODescriptions(cell, controller, ios, direction, valueType, group, options);
+        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['VirtualControllerInputsOutputsApi.listVirtualControllerIODescriptions']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['VirtualControllerInputsOutputsApi.listVirtualRobotIODescriptions']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -9334,7 +9255,7 @@ export const VirtualControllerInputsOutputsApiFactory = function (configuration,
     const localVarFp = VirtualControllerInputsOutputsApiFp(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).
+         * 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 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.
@@ -9357,8 +9278,8 @@ export const VirtualControllerInputsOutputsApiFactory = function (configuration,
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listVirtualControllerIODescriptions(cell, controller, ios, direction, valueType, group, options) {
-            return localVarFp.listVirtualControllerIODescriptions(cell, controller, ios, direction, valueType, group, options).then((request) => request(axios, basePath));
+        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.
@@ -9382,7 +9303,7 @@ export const VirtualControllerInputsOutputsApiFactory = function (configuration,
  */
 export class VirtualControllerInputsOutputsApi extends BaseAPI {
     /**
-     * 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).
+     * 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 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.
@@ -9407,8 +9328,8 @@ export class VirtualControllerInputsOutputsApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof VirtualControllerInputsOutputsApi
      */
-    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));
+    listVirtualRobotIODescriptions(cell, controller, ios, direction, valueType, group, options) {
+        return VirtualControllerInputsOutputsApiFp(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.