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

package/v2/api.ts

@@ -870,37 +870,6 @@ export interface ContainerStorage {
      */
     'capacity': string;
 }
-/**
- * The data type to describe a robot controller.
- * @export
- * @interface ControllerDescription
- */
-export interface ControllerDescription {
-    /**
-     * 
-     * @type {Array<string>}
-     * @memberof ControllerDescription
-     */
-    'connected_motion_groups': Array<string>;
-    /**
-     * Can this controller be moved through freedrive (true), or not (false).
-     * @type {boolean}
-     * @memberof ControllerDescription
-     */
-    'supports_freedrive': boolean;
-    /**
-     * Can this controller be controlled with NOVA (true) or is it only possible to read data (false).
-     * @type {boolean}
-     * @memberof ControllerDescription
-     */
-    'supports_control': boolean;
-    /**
-     * True if NOVA supports reading safety zone-, tool- and link-geometries for this motion group. Safety zones are used to define areas where the robot should slow down or stop. If false, NOVA can\'t guarantee that the executed motions respect safety zones defined on the controller. 
-     * @type {boolean}
-     * @memberof ControllerDescription
-     */
-    'supports_safety_zones': boolean;
-}
 /**
  * Defines a convex hull encapsulating a set of vertices.
  * @export
@@ -1126,6 +1095,39 @@ export const Direction = {
 export type Direction = typeof Direction[keyof typeof Direction];
 
 
+/**
+ * 
+ * @export
+ * @interface EndOfTrajectory
+ */
+export interface EndOfTrajectory {
+    /**
+     * 
+     * @type {string}
+     * @memberof EndOfTrajectory
+     */
+    'kind': EndOfTrajectoryKindEnum;
+}
+
+export const EndOfTrajectoryKindEnum = {
+    EndOfTrajectory: 'END_OF_TRAJECTORY'
+} as const;
+
+export type EndOfTrajectoryKindEnum = typeof EndOfTrajectoryKindEnum[keyof typeof EndOfTrajectoryKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface Error2
+ */
+export interface Error2 {
+    /**
+     * 
+     * @type {string}
+     * @memberof Error2
+     */
+    'message': string;
+}
 /**
  * Details about the state of the motion execution. The details are either for a jogging or a trajectory. If NOVA is not controlling this motion group at the moment, this field is omitted. 
  * @export
@@ -2013,119 +2015,7 @@ export type JoggingDetailsKindEnum = typeof JoggingDetailsKindEnum[keyof typeof
  * @type JoggingDetailsState
  * @export
  */
-export type JoggingDetailsState = JoggingPausedByUser | JoggingPausedNearCollision | JoggingPausedNearJointLimit | JoggingPausedOnIO | JoggingRunning;
-
-/**
- * 
- * @export
- * @interface JoggingPausedByUser
- */
-export interface JoggingPausedByUser {
-    /**
-     * 
-     * @type {string}
-     * @memberof JoggingPausedByUser
-     */
-    'kind': JoggingPausedByUserKindEnum;
-}
-
-export const JoggingPausedByUserKindEnum = {
-    PausedByUser: 'PAUSED_BY_USER'
-} as const;
-
-export type JoggingPausedByUserKindEnum = typeof JoggingPausedByUserKindEnum[keyof typeof JoggingPausedByUserKindEnum];
-
-/**
- * 
- * @export
- * @interface JoggingPausedNearCollision
- */
-export interface JoggingPausedNearCollision {
-    /**
-     * 
-     * @type {string}
-     * @memberof JoggingPausedNearCollision
-     */
-    'kind': JoggingPausedNearCollisionKindEnum;
-    /**
-     * 
-     * @type {string}
-     * @memberof JoggingPausedNearCollision
-     */
-    'description': string;
-}
-
-export const JoggingPausedNearCollisionKindEnum = {
-    PausedNearCollision: 'PAUSED_NEAR_COLLISION'
-} as const;
-
-export type JoggingPausedNearCollisionKindEnum = typeof JoggingPausedNearCollisionKindEnum[keyof typeof JoggingPausedNearCollisionKindEnum];
-
-/**
- * 
- * @export
- * @interface JoggingPausedNearJointLimit
- */
-export interface JoggingPausedNearJointLimit {
-    /**
-     * 
-     * @type {string}
-     * @memberof JoggingPausedNearJointLimit
-     */
-    'kind': JoggingPausedNearJointLimitKindEnum;
-    /**
-     * 
-     * @type {Array<number>}
-     * @memberof JoggingPausedNearJointLimit
-     */
-    'joint_indices': Array<number>;
-}
-
-export const JoggingPausedNearJointLimitKindEnum = {
-    PausedNearJointLimit: 'PAUSED_NEAR_JOINT_LIMIT'
-} as const;
-
-export type JoggingPausedNearJointLimitKindEnum = typeof JoggingPausedNearJointLimitKindEnum[keyof typeof JoggingPausedNearJointLimitKindEnum];
-
-/**
- * 
- * @export
- * @interface JoggingPausedOnIO
- */
-export interface JoggingPausedOnIO {
-    /**
-     * 
-     * @type {string}
-     * @memberof JoggingPausedOnIO
-     */
-    'kind': JoggingPausedOnIOKindEnum;
-}
-
-export const JoggingPausedOnIOKindEnum = {
-    PausedOnIo: 'PAUSED_ON_IO'
-} as const;
-
-export type JoggingPausedOnIOKindEnum = typeof JoggingPausedOnIOKindEnum[keyof typeof JoggingPausedOnIOKindEnum];
-
-/**
- * 
- * @export
- * @interface JoggingRunning
- */
-export interface JoggingRunning {
-    /**
-     * 
-     * @type {string}
-     * @memberof JoggingRunning
-     */
-    'kind': JoggingRunningKindEnum;
-}
-
-export const JoggingRunningKindEnum = {
-    Running: 'RUNNING'
-} as const;
-
-export type JoggingRunningKindEnum = typeof JoggingRunningKindEnum[keyof typeof JoggingRunningKindEnum];
+export type JoggingDetailsState = PausedByUser | PausedNearCollision | PausedNearJointLimit | PausedOnIO | Running;
 
 /**
  * 
@@ -3276,6 +3166,118 @@ export interface PauseOnIO {
 }
 
 
+/**
+ * 
+ * @export
+ * @interface PausedByRequest
+ */
+export interface PausedByRequest {
+    /**
+     * 
+     * @type {string}
+     * @memberof PausedByRequest
+     */
+    'kind': PausedByRequestKindEnum;
+}
+
+export const PausedByRequestKindEnum = {
+    PausedByUser: 'PAUSED_BY_USER'
+} as const;
+
+export type PausedByRequestKindEnum = typeof PausedByRequestKindEnum[keyof typeof PausedByRequestKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface PausedByUser
+ */
+export interface PausedByUser {
+    /**
+     * 
+     * @type {string}
+     * @memberof PausedByUser
+     */
+    'kind': PausedByUserKindEnum;
+}
+
+export const PausedByUserKindEnum = {
+    PausedByUser: 'PAUSED_BY_USER'
+} as const;
+
+export type PausedByUserKindEnum = typeof PausedByUserKindEnum[keyof typeof PausedByUserKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface PausedNearCollision
+ */
+export interface PausedNearCollision {
+    /**
+     * 
+     * @type {string}
+     * @memberof PausedNearCollision
+     */
+    'kind': PausedNearCollisionKindEnum;
+    /**
+     * 
+     * @type {string}
+     * @memberof PausedNearCollision
+     */
+    'description': string;
+}
+
+export const PausedNearCollisionKindEnum = {
+    PausedNearCollision: 'PAUSED_NEAR_COLLISION'
+} as const;
+
+export type PausedNearCollisionKindEnum = typeof PausedNearCollisionKindEnum[keyof typeof PausedNearCollisionKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface PausedNearJointLimit
+ */
+export interface PausedNearJointLimit {
+    /**
+     * 
+     * @type {string}
+     * @memberof PausedNearJointLimit
+     */
+    'kind': PausedNearJointLimitKindEnum;
+    /**
+     * 
+     * @type {Array<number>}
+     * @memberof PausedNearJointLimit
+     */
+    'joint_indices': Array<number>;
+}
+
+export const PausedNearJointLimitKindEnum = {
+    PausedNearJointLimit: 'PAUSED_NEAR_JOINT_LIMIT'
+} as const;
+
+export type PausedNearJointLimitKindEnum = typeof PausedNearJointLimitKindEnum[keyof typeof PausedNearJointLimitKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface PausedOnIO
+ */
+export interface PausedOnIO {
+    /**
+     * 
+     * @type {string}
+     * @memberof PausedOnIO
+     */
+    'kind': PausedOnIOKindEnum;
+}
+
+export const PausedOnIOKindEnum = {
+    PausedOnIo: 'PAUSED_ON_IO'
+} as const;
+
+export type PausedOnIOKindEnum = typeof PausedOnIOKindEnum[keyof typeof PausedOnIOKindEnum];
+
 /**
  * 
  * @export
@@ -3564,7 +3566,7 @@ export type ReleaseChannel = typeof ReleaseChannel[keyof typeof ReleaseChannel];
  */
 export interface RobotController {
     /**
-     * Unique name of controller within the cell. It must be a valid k8s label name as defined by [RFC 1035](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#rfc-1035-label-names). 
+     * A unique name of the Controller inside the Cell. It must be a valid k8s label name as defined by [RFC 1035](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#rfc-1035-label-names).
      * @type {string}
      * @memberof RobotController
      */
@@ -3771,6 +3773,52 @@ export interface RobotTcpData {
 }
 
 
+/**
+ * 
+ * @export
+ * @interface Running
+ */
+export interface Running {
+    /**
+     * 
+     * @type {string}
+     * @memberof Running
+     */
+    'kind': RunningKindEnum;
+}
+
+export const RunningKindEnum = {
+    Running: 'RUNNING'
+} as const;
+
+export type RunningKindEnum = typeof RunningKindEnum[keyof typeof RunningKindEnum];
+
+/**
+ * 
+ * @export
+ * @interface Running1
+ */
+export interface Running1 {
+    /**
+     * 
+     * @type {string}
+     * @memberof Running1
+     */
+    'kind': Running1KindEnum;
+    /**
+     * Remaining time in milliseconds (ms) to reach the end of the motion.
+     * @type {number}
+     * @memberof Running1
+     */
+    'time_to_end': number;
+}
+
+export const Running1KindEnum = {
+    Running: 'RUNNING'
+} as const;
+
+export type Running1KindEnum = typeof Running1KindEnum[keyof typeof Running1KindEnum];
+
 /**
  * Current safety state of the configured robot controller. Operation modes in which the attached motion groups can be moved are: - SAFETY_STATE_NORMAL - SAFETY_STATE_REDUCED All other modes are considered as non-operational. 
  * @export
@@ -4341,27 +4389,7 @@ export type TrajectoryDetailsKindEnum = typeof TrajectoryDetailsKindEnum[keyof t
  * @type TrajectoryDetailsState
  * @export
  */
-export type TrajectoryDetailsState = TrajectoryEnded | TrajectoryPausedByUser | TrajectoryPausedOnIO | TrajectoryRunning | TrajectoryWaitForIO;
-
-/**
- * 
- * @export
- * @interface TrajectoryEnded
- */
-export interface TrajectoryEnded {
-    /**
-     * 
-     * @type {string}
-     * @memberof TrajectoryEnded
-     */
-    'kind': TrajectoryEndedKindEnum;
-}
-
-export const TrajectoryEndedKindEnum = {
-    EndOfTrajectory: 'END_OF_TRAJECTORY'
-} as const;
-
-export type TrajectoryEndedKindEnum = typeof TrajectoryEndedKindEnum[keyof typeof TrajectoryEndedKindEnum];
+export type TrajectoryDetailsState = EndOfTrajectory | PausedByRequest | PausedOnIO | Running1 | WaitForIO;
 
 /**
  * 
@@ -4389,92 +4417,6 @@ export const TrajectoryIdMessageTypeEnum = {
 
 export type TrajectoryIdMessageTypeEnum = typeof TrajectoryIdMessageTypeEnum[keyof typeof TrajectoryIdMessageTypeEnum];
 
-/**
- * 
- * @export
- * @interface TrajectoryPausedByUser
- */
-export interface TrajectoryPausedByUser {
-    /**
-     * 
-     * @type {string}
-     * @memberof TrajectoryPausedByUser
-     */
-    'kind': TrajectoryPausedByUserKindEnum;
-}
-
-export const TrajectoryPausedByUserKindEnum = {
-    PausedByUser: 'PAUSED_BY_USER'
-} as const;
-
-export type TrajectoryPausedByUserKindEnum = typeof TrajectoryPausedByUserKindEnum[keyof typeof TrajectoryPausedByUserKindEnum];
-
-/**
- * 
- * @export
- * @interface TrajectoryPausedOnIO
- */
-export interface TrajectoryPausedOnIO {
-    /**
-     * 
-     * @type {string}
-     * @memberof TrajectoryPausedOnIO
-     */
-    'kind': TrajectoryPausedOnIOKindEnum;
-}
-
-export const TrajectoryPausedOnIOKindEnum = {
-    PausedOnIo: 'PAUSED_ON_IO'
-} as const;
-
-export type TrajectoryPausedOnIOKindEnum = typeof TrajectoryPausedOnIOKindEnum[keyof typeof TrajectoryPausedOnIOKindEnum];
-
-/**
- * 
- * @export
- * @interface TrajectoryRunning
- */
-export interface TrajectoryRunning {
-    /**
-     * 
-     * @type {string}
-     * @memberof TrajectoryRunning
-     */
-    'kind': TrajectoryRunningKindEnum;
-    /**
-     * Remaining time in milliseconds (ms) to reach the end of the motion.
-     * @type {number}
-     * @memberof TrajectoryRunning
-     */
-    'time_to_end': number;
-}
-
-export const TrajectoryRunningKindEnum = {
-    Running: 'RUNNING'
-} as const;
-
-export type TrajectoryRunningKindEnum = typeof TrajectoryRunningKindEnum[keyof typeof TrajectoryRunningKindEnum];
-
-/**
- * 
- * @export
- * @interface TrajectoryWaitForIO
- */
-export interface TrajectoryWaitForIO {
-    /**
-     * 
-     * @type {string}
-     * @memberof TrajectoryWaitForIO
-     */
-    'kind': TrajectoryWaitForIOKindEnum;
-}
-
-export const TrajectoryWaitForIOKindEnum = {
-    WaitForIo: 'WAIT_FOR_IO'
-} as const;
-
-export type TrajectoryWaitForIOKindEnum = typeof TrajectoryWaitForIOKindEnum[keyof typeof TrajectoryWaitForIOKindEnum];
-
 /**
  * The unit of input/output value.
  * @export
@@ -4570,7 +4512,7 @@ export interface ValidationError {
 export type ValidationErrorLocInner = number | string;
 
 /**
- * The configuration of a virtual robot controller has to contain the manufacturer string, an optional joint position string array and either a preset `type` **or** the complete JSON configuration. 
+ * The configuration of a virtual robot controller has to contain the manufacturer string, an optional joint position string array and either a type or the full JSON configuration. The JSON config of a physical controller can be obtained via `/cells/{cell}/controllers/{controller}/virtual-robot-configuration` 
  * @export
  * @interface VirtualController
  */
@@ -4594,7 +4536,7 @@ export interface VirtualController {
      */
     'type'?: VirtualControllerTypes;
     /**
-     * Complete JSON configuration of the virtual robot controller. Can be obtained from the physical controller\'s configuration via [getVirtualControllerConfiguration](getVirtualControllerConfiguration). If provided, the `type` field should not be used. 
+     * 
      * @type {string}
      * @memberof VirtualController
      */
@@ -4751,6 +4693,26 @@ export interface VirtualRobotConfiguration {
      */
     'content': string;
 }
+/**
+ * 
+ * @export
+ * @interface WaitForIO
+ */
+export interface WaitForIO {
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitForIO
+     */
+    'kind': WaitForIOKindEnum;
+}
+
+export const WaitForIOKindEnum = {
+    WaitForIo: 'WAIT_FOR_IO'
+} as const;
+
+export type WaitForIOKindEnum = typeof WaitForIOKindEnum[keyof typeof WaitForIOKindEnum];
+
 /**
  * The value to compare with the current value of the input/output.
  * @export
@@ -6135,52 +6097,6 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
 
 
     
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Get 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: string, controller: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            // 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 = {} as any;
-            const localVarQueryParameter = {} as any;
-
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration)
-
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration)
-
-
-    
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
@@ -6384,18 +6300,18 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
             };
         },
         /**
-         * 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: string, controller: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        getVirtualRobotConfiguration: async (cell: string, controller: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // 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)));
@@ -6788,20 +6704,6 @@ export const ControllerApiFp = function(configuration?: 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: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ControllerDescription>> {
-            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
@@ -6861,17 +6763,17 @@ export const ControllerApiFp = function(configuration?: 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: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VirtualRobotConfiguration>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getVirtualControllerConfiguration(cell, controller, options);
+        async getVirtualRobotConfiguration(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VirtualRobotConfiguration>> {
+            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);
         },
         /**
@@ -7008,17 +6910,6 @@ export const ControllerApiFactory = function (configuration?: Configuration, bas
         deleteRobotController(cell: string, controller: string, completionTimeout?: number, options?: RawAxiosRequestConfig): AxiosPromise<void> {
             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: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<ControllerDescription> {
-            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
@@ -7066,15 +6957,15 @@ export const ControllerApiFactory = function (configuration?: Configuration, bas
             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: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<VirtualRobotConfiguration> {
-            return localVarFp.getVirtualControllerConfiguration(cell, controller, options).then((request) => request(axios, basePath));
+        getVirtualRobotConfiguration(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<VirtualRobotConfiguration> {
+            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. 
@@ -7198,19 +7089,6 @@ export class ControllerApi extends BaseAPI {
         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
-     */
-    public getControllerDescription(cell: string, controller: string, options?: RawAxiosRequestConfig) {
-        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
@@ -7266,16 +7144,16 @@ export class ControllerApi extends BaseAPI {
     }
 
     /**
-     * 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
      */
-    public getVirtualControllerConfiguration(cell: string, controller: string, options?: RawAxiosRequestConfig) {
-        return ControllerApiFp(this.configuration).getVirtualControllerConfiguration(cell, controller, options).then((request) => request(this.axios, this.basePath));
+    public getVirtualRobotConfiguration(cell: string, controller: string, options?: RawAxiosRequestConfig) {
+        return ControllerApiFp(this.configuration).getVirtualRobotConfiguration(cell, controller, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -12476,15 +12354,15 @@ export const VirtualControllerApiAxiosParamCreator = function (configuration?: C
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        addVirtualControllerCoordinateSystem: async (cell: string, controller: string, coordinateSystem: string, coordinateSystemData: CoordinateSystemData, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        addVirtualRobotCoordinateSystem: async (cell: string, controller: string, coordinateSystem: string, coordinateSystemData: CoordinateSystemData, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // 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)))
@@ -12533,17 +12411,17 @@ export const VirtualControllerApiAxiosParamCreator = function (configuration?: C
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        addVirtualControllerTcp: async (cell: string, controller: string, motionGroup: string, tcp: string, robotTcpData: RobotTcpData, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        addVirtualRobotTcp: async (cell: string, controller: string, motionGroup: string, tcp: string, robotTcpData: RobotTcpData, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // 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)))
@@ -12592,13 +12470,13 @@ export const VirtualControllerApiAxiosParamCreator = function (configuration?: C
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        deleteVirtualControllerCoordinateSystem: async (cell: string, controller: string, coordinateSystem: string, deleteDependent?: boolean, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        deleteVirtualRobotCoordinateSystem: async (cell: string, controller: string, coordinateSystem: string, deleteDependent?: boolean, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // 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)))
@@ -12647,15 +12525,15 @@ export const VirtualControllerApiAxiosParamCreator = function (configuration?: C
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        deleteVirtualControllerTcp: async (cell: string, controller: string, motionGroup: string, tcp: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        deleteVirtualRobotTcp: async (cell: string, controller: string, motionGroup: string, tcp: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // 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)))
@@ -12888,13 +12766,13 @@ export const VirtualControllerApiAxiosParamCreator = function (configuration?: C
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getVirtualControllerMounting: async (cell: string, controller: string, motionGroup: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        getVirtualRobotMounting: async (cell: string, controller: string, motionGroup: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // 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)))
@@ -12937,11 +12815,11 @@ export const VirtualControllerApiAxiosParamCreator = function (configuration?: C
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listVirtualControllerCoordinateSystems: async (cell: string, controller: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        listVirtualRobotCoordinateSystems: async (cell: string, controller: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // 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)));
@@ -12984,13 +12862,13 @@ export const VirtualControllerApiAxiosParamCreator = function (configuration?: C
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listVirtualControllerTcps: async (cell: string, controller: string, motionGroup: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        listVirtualRobotTcps: async (cell: string, controller: string, motionGroup: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // 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)))
@@ -13195,15 +13073,15 @@ export const VirtualControllerApiAxiosParamCreator = function (configuration?: C
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        setVirtualControllerMounting: async (cell: string, controller: string, motionGroup: string, coordinateSystem: CoordinateSystem, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        setVirtualRobotMounting: async (cell: string, controller: string, motionGroup: string, coordinateSystem: CoordinateSystem, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // 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)))
@@ -13261,10 +13139,10 @@ export const VirtualControllerApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async addVirtualControllerCoordinateSystem(cell: string, controller: string, coordinateSystem: string, coordinateSystemData: CoordinateSystemData, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.addVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options);
+        async addVirtualRobotCoordinateSystem(cell: string, controller: string, coordinateSystem: string, coordinateSystemData: CoordinateSystemData, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            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);
         },
         /**
@@ -13278,10 +13156,10 @@ export const VirtualControllerApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async addVirtualControllerTcp(cell: string, controller: string, motionGroup: string, tcp: string, robotTcpData: RobotTcpData, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.addVirtualControllerTcp(cell, controller, motionGroup, tcp, robotTcpData, options);
+        async addVirtualRobotTcp(cell: string, controller: string, motionGroup: string, tcp: string, robotTcpData: RobotTcpData, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            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);
         },
         /**
@@ -13294,10 +13172,10 @@ export const VirtualControllerApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async deleteVirtualControllerCoordinateSystem(cell: string, controller: string, coordinateSystem: string, deleteDependent?: boolean, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.deleteVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options);
+        async deleteVirtualRobotCoordinateSystem(cell: string, controller: string, coordinateSystem: string, deleteDependent?: boolean, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            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);
         },
         /**
@@ -13310,10 +13188,10 @@ export const VirtualControllerApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async deleteVirtualControllerTcp(cell: string, controller: string, motionGroup: string, tcp: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.deleteVirtualControllerTcp(cell, controller, motionGroup, tcp, options);
+        async deleteVirtualRobotTcp(cell: string, controller: string, motionGroup: string, tcp: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            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);
         },
         /**
@@ -13382,10 +13260,10 @@ export const VirtualControllerApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async getVirtualControllerMounting(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CoordinateSystem>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getVirtualControllerMounting(cell, controller, motionGroup, options);
+        async getVirtualRobotMounting(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CoordinateSystem>> {
+            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);
         },
         /**
@@ -13396,10 +13274,10 @@ export const VirtualControllerApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async listVirtualControllerCoordinateSystems(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<CoordinateSystem>>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listVirtualControllerCoordinateSystems(cell, controller, options);
+        async listVirtualRobotCoordinateSystems(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<CoordinateSystem>>> {
+            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);
         },
         /**
@@ -13411,10 +13289,10 @@ export const VirtualControllerApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async listVirtualControllerTcps(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<RobotTcp>>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listVirtualControllerTcps(cell, controller, motionGroup, options);
+        async listVirtualRobotTcps(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<RobotTcp>>> {
+            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);
         },
         /**
@@ -13473,10 +13351,10 @@ export const VirtualControllerApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async setVirtualControllerMounting(cell: string, controller: string, motionGroup: string, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CoordinateSystem>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.setVirtualControllerMounting(cell, controller, motionGroup, coordinateSystem, options);
+        async setVirtualRobotMounting(cell: string, controller: string, motionGroup: string, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CoordinateSystem>> {
+            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);
         },
     }
@@ -13499,8 +13377,8 @@ export const VirtualControllerApiFactory = function (configuration?: Configurati
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        addVirtualControllerCoordinateSystem(cell: string, controller: string, coordinateSystem: string, coordinateSystemData: CoordinateSystemData, options?: RawAxiosRequestConfig): AxiosPromise<void> {
-            return localVarFp.addVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options).then((request) => request(axios, basePath));
+        addVirtualRobotCoordinateSystem(cell: string, controller: string, coordinateSystem: string, coordinateSystemData: CoordinateSystemData, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            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. 
@@ -13513,8 +13391,8 @@ export const VirtualControllerApiFactory = function (configuration?: Configurati
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        addVirtualControllerTcp(cell: string, controller: string, motionGroup: string, tcp: string, robotTcpData: RobotTcpData, options?: RawAxiosRequestConfig): AxiosPromise<void> {
-            return localVarFp.addVirtualControllerTcp(cell, controller, motionGroup, tcp, robotTcpData, options).then((request) => request(axios, basePath));
+        addVirtualRobotTcp(cell: string, controller: string, motionGroup: string, tcp: string, robotTcpData: RobotTcpData, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            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. 
@@ -13526,8 +13404,8 @@ export const VirtualControllerApiFactory = function (configuration?: Configurati
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        deleteVirtualControllerCoordinateSystem(cell: string, controller: string, coordinateSystem: string, deleteDependent?: boolean, options?: RawAxiosRequestConfig): AxiosPromise<void> {
-            return localVarFp.deleteVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options).then((request) => request(axios, basePath));
+        deleteVirtualRobotCoordinateSystem(cell: string, controller: string, coordinateSystem: string, deleteDependent?: boolean, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            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. 
@@ -13539,8 +13417,8 @@ export const VirtualControllerApiFactory = function (configuration?: Configurati
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        deleteVirtualControllerTcp(cell: string, controller: string, motionGroup: string, tcp: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
-            return localVarFp.deleteVirtualControllerTcp(cell, controller, motionGroup, tcp, options).then((request) => request(axios, basePath));
+        deleteVirtualRobotTcp(cell: string, controller: string, motionGroup: string, tcp: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            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. 
@@ -13596,8 +13474,8 @@ export const VirtualControllerApiFactory = function (configuration?: Configurati
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getVirtualControllerMounting(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise<CoordinateSystem> {
-            return localVarFp.getVirtualControllerMounting(cell, controller, motionGroup, options).then((request) => request(axios, basePath));
+        getVirtualRobotMounting(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise<CoordinateSystem> {
+            return localVarFp.getVirtualRobotMounting(cell, controller, motionGroup, options).then((request) => request(axios, basePath));
         },
         /**
          * Lists all coordinate systems on the robot controller. 
@@ -13607,8 +13485,8 @@ export const VirtualControllerApiFactory = function (configuration?: Configurati
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listVirtualControllerCoordinateSystems(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<CoordinateSystem>> {
-            return localVarFp.listVirtualControllerCoordinateSystems(cell, controller, options).then((request) => request(axios, basePath));
+        listVirtualRobotCoordinateSystems(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<CoordinateSystem>> {
+            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. 
@@ -13619,8 +13497,8 @@ export const VirtualControllerApiFactory = function (configuration?: Configurati
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listVirtualControllerTcps(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<RobotTcp>> {
-            return localVarFp.listVirtualControllerTcps(cell, controller, motionGroup, options).then((request) => request(axios, basePath));
+        listVirtualRobotTcps(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<RobotTcp>> {
+            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. 
@@ -13669,8 +13547,8 @@ export const VirtualControllerApiFactory = function (configuration?: Configurati
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        setVirtualControllerMounting(cell: string, controller: string, motionGroup: string, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig): AxiosPromise<CoordinateSystem> {
-            return localVarFp.setVirtualControllerMounting(cell, controller, motionGroup, coordinateSystem, options).then((request) => request(axios, basePath));
+        setVirtualRobotMounting(cell: string, controller: string, motionGroup: string, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig): AxiosPromise<CoordinateSystem> {
+            return localVarFp.setVirtualRobotMounting(cell, controller, motionGroup, coordinateSystem, options).then((request) => request(axios, basePath));
         },
     };
 };
@@ -13693,8 +13571,8 @@ export class VirtualControllerApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof VirtualControllerApi
      */
-    public addVirtualControllerCoordinateSystem(cell: string, controller: string, coordinateSystem: string, coordinateSystemData: CoordinateSystemData, options?: RawAxiosRequestConfig) {
-        return VirtualControllerApiFp(this.configuration).addVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options).then((request) => request(this.axios, this.basePath));
+    public addVirtualRobotCoordinateSystem(cell: string, controller: string, coordinateSystem: string, coordinateSystemData: CoordinateSystemData, options?: RawAxiosRequestConfig) {
+        return VirtualControllerApiFp(this.configuration).addVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, coordinateSystemData, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -13709,8 +13587,8 @@ export class VirtualControllerApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof VirtualControllerApi
      */
-    public addVirtualControllerTcp(cell: string, controller: string, motionGroup: string, tcp: string, robotTcpData: RobotTcpData, options?: RawAxiosRequestConfig) {
-        return VirtualControllerApiFp(this.configuration).addVirtualControllerTcp(cell, controller, motionGroup, tcp, robotTcpData, options).then((request) => request(this.axios, this.basePath));
+    public addVirtualRobotTcp(cell: string, controller: string, motionGroup: string, tcp: string, robotTcpData: RobotTcpData, options?: RawAxiosRequestConfig) {
+        return VirtualControllerApiFp(this.configuration).addVirtualRobotTcp(cell, controller, motionGroup, tcp, robotTcpData, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -13724,8 +13602,8 @@ export class VirtualControllerApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof VirtualControllerApi
      */
-    public deleteVirtualControllerCoordinateSystem(cell: string, controller: string, coordinateSystem: string, deleteDependent?: boolean, options?: RawAxiosRequestConfig) {
-        return VirtualControllerApiFp(this.configuration).deleteVirtualControllerCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options).then((request) => request(this.axios, this.basePath));
+    public deleteVirtualRobotCoordinateSystem(cell: string, controller: string, coordinateSystem: string, deleteDependent?: boolean, options?: RawAxiosRequestConfig) {
+        return VirtualControllerApiFp(this.configuration).deleteVirtualRobotCoordinateSystem(cell, controller, coordinateSystem, deleteDependent, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -13739,8 +13617,8 @@ export class VirtualControllerApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof VirtualControllerApi
      */
-    public deleteVirtualControllerTcp(cell: string, controller: string, motionGroup: string, tcp: string, options?: RawAxiosRequestConfig) {
-        return VirtualControllerApiFp(this.configuration).deleteVirtualControllerTcp(cell, controller, motionGroup, tcp, options).then((request) => request(this.axios, this.basePath));
+    public deleteVirtualRobotTcp(cell: string, controller: string, motionGroup: string, tcp: string, options?: RawAxiosRequestConfig) {
+        return VirtualControllerApiFp(this.configuration).deleteVirtualRobotTcp(cell, controller, motionGroup, tcp, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -13806,8 +13684,8 @@ export class VirtualControllerApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof VirtualControllerApi
      */
-    public getVirtualControllerMounting(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig) {
-        return VirtualControllerApiFp(this.configuration).getVirtualControllerMounting(cell, controller, motionGroup, options).then((request) => request(this.axios, this.basePath));
+    public getVirtualRobotMounting(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig) {
+        return VirtualControllerApiFp(this.configuration).getVirtualRobotMounting(cell, controller, motionGroup, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -13819,8 +13697,8 @@ export class VirtualControllerApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof VirtualControllerApi
      */
-    public listVirtualControllerCoordinateSystems(cell: string, controller: string, options?: RawAxiosRequestConfig) {
-        return VirtualControllerApiFp(this.configuration).listVirtualControllerCoordinateSystems(cell, controller, options).then((request) => request(this.axios, this.basePath));
+    public listVirtualRobotCoordinateSystems(cell: string, controller: string, options?: RawAxiosRequestConfig) {
+        return VirtualControllerApiFp(this.configuration).listVirtualRobotCoordinateSystems(cell, controller, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -13833,8 +13711,8 @@ export class VirtualControllerApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof VirtualControllerApi
      */
-    public listVirtualControllerTcps(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig) {
-        return VirtualControllerApiFp(this.configuration).listVirtualControllerTcps(cell, controller, motionGroup, options).then((request) => request(this.axios, this.basePath));
+    public listVirtualRobotTcps(cell: string, controller: string, motionGroup: string, options?: RawAxiosRequestConfig) {
+        return VirtualControllerApiFp(this.configuration).listVirtualRobotTcps(cell, controller, motionGroup, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -13891,8 +13769,8 @@ export class VirtualControllerApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof VirtualControllerApi
      */
-    public setVirtualControllerMounting(cell: string, controller: string, motionGroup: string, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig) {
-        return VirtualControllerApiFp(this.configuration).setVirtualControllerMounting(cell, controller, motionGroup, coordinateSystem, options).then((request) => request(this.axios, this.basePath));
+    public setVirtualRobotMounting(cell: string, controller: string, motionGroup: string, coordinateSystem: CoordinateSystem, options?: RawAxiosRequestConfig) {
+        return VirtualControllerApiFp(this.configuration).setVirtualRobotMounting(cell, controller, motionGroup, coordinateSystem, options).then((request) => request(this.axios, this.basePath));
     }
 }
 
@@ -14003,18 +13881,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: string, controller: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        getVirtualRobotBehavior: async (cell: string, controller: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // 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)));
@@ -14057,11 +13935,11 @@ export const VirtualControllerBehaviorApiAxiosParamCreator = function (configura
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        setVirtualControllerBehavior: async (cell: string, controller: string, behavior?: Behavior, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        setVirtualRobotBehavior: async (cell: string, controller: string, behavior?: Behavior, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // 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)));
@@ -14139,17 +14017,17 @@ export const VirtualControllerBehaviorApiFp = function(configuration?: Configura
             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: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Behavior>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getVirtualControllerBehavior(cell, controller, options);
+        async getVirtualRobotBehavior(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Behavior>> {
+            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);
         },
         /**
@@ -14161,10 +14039,10 @@ export const VirtualControllerBehaviorApiFp = function(configuration?: Configura
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async setVirtualControllerBehavior(cell: string, controller: string, behavior?: Behavior, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.setVirtualControllerBehavior(cell, controller, behavior, options);
+        async setVirtualRobotBehavior(cell: string, controller: string, behavior?: Behavior, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            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);
         },
     }
@@ -14201,15 +14079,15 @@ export const VirtualControllerBehaviorApiFactory = function (configuration?: Con
             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: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<Behavior> {
-            return localVarFp.getVirtualControllerBehavior(cell, controller, options).then((request) => request(axios, basePath));
+        getVirtualRobotBehavior(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<Behavior> {
+            return localVarFp.getVirtualRobotBehavior(cell, controller, options).then((request) => request(axios, basePath));
         },
         /**
          * Set virtual controller behavior. 
@@ -14220,8 +14098,8 @@ export const VirtualControllerBehaviorApiFactory = function (configuration?: Con
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        setVirtualControllerBehavior(cell: string, controller: string, behavior?: Behavior, options?: RawAxiosRequestConfig): AxiosPromise<void> {
-            return localVarFp.setVirtualControllerBehavior(cell, controller, behavior, options).then((request) => request(axios, basePath));
+        setVirtualRobotBehavior(cell: string, controller: string, behavior?: Behavior, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.setVirtualRobotBehavior(cell, controller, behavior, options).then((request) => request(axios, basePath));
         },
     };
 };
@@ -14261,7 +14139,7 @@ export class VirtualControllerBehaviorApi extends BaseAPI {
     }
 
     /**
-     * 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.
@@ -14269,8 +14147,8 @@ export class VirtualControllerBehaviorApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof VirtualControllerBehaviorApi
      */
-    public getVirtualControllerBehavior(cell: string, controller: string, options?: RawAxiosRequestConfig) {
-        return VirtualControllerBehaviorApiFp(this.configuration).getVirtualControllerBehavior(cell, controller, options).then((request) => request(this.axios, this.basePath));
+    public getVirtualRobotBehavior(cell: string, controller: string, options?: RawAxiosRequestConfig) {
+        return VirtualControllerBehaviorApiFp(this.configuration).getVirtualRobotBehavior(cell, controller, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -14283,8 +14161,8 @@ export class VirtualControllerBehaviorApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof VirtualControllerBehaviorApi
      */
-    public setVirtualControllerBehavior(cell: string, controller: string, behavior?: Behavior, options?: RawAxiosRequestConfig) {
-        return VirtualControllerBehaviorApiFp(this.configuration).setVirtualControllerBehavior(cell, controller, behavior, options).then((request) => request(this.axios, this.basePath));
+    public setVirtualRobotBehavior(cell: string, controller: string, behavior?: Behavior, options?: RawAxiosRequestConfig) {
+        return VirtualControllerBehaviorApiFp(this.configuration).setVirtualRobotBehavior(cell, controller, behavior, options).then((request) => request(this.axios, this.basePath));
     }
 }
 
@@ -14297,7 +14175,7 @@ export class VirtualControllerBehaviorApi extends BaseAPI {
 export const VirtualControllerInputsOutputsApiAxiosParamCreator = function (configuration?: 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.
@@ -14361,11 +14239,11 @@ export const VirtualControllerInputsOutputsApiAxiosParamCreator = function (conf
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listVirtualControllerIODescriptions: async (cell: string, controller: string, ios?: Array<string>, direction?: IODirection, valueType?: IOValueType, group?: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        listVirtualRobotIODescriptions: async (cell: string, controller: string, ios?: Array<string>, direction?: IODirection, valueType?: IOValueType, group?: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // 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)));
@@ -14478,7 +14356,7 @@ export const VirtualControllerInputsOutputsApiFp = function(configuration?: Conf
     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.
@@ -14504,10 +14382,10 @@ export const VirtualControllerInputsOutputsApiFp = function(configuration?: Conf
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async listVirtualControllerIODescriptions(cell: string, controller: string, ios?: Array<string>, direction?: IODirection, valueType?: IOValueType, group?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<IODescription>>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listVirtualControllerIODescriptions(cell, controller, ios, direction, valueType, group, options);
+        async listVirtualRobotIODescriptions(cell: string, controller: string, ios?: Array<string>, direction?: IODirection, valueType?: IOValueType, group?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<IODescription>>> {
+            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);
         },
         /**
@@ -14536,7 +14414,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.
@@ -14559,8 +14437,8 @@ export const VirtualControllerInputsOutputsApiFactory = function (configuration?
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listVirtualControllerIODescriptions(cell: string, controller: string, ios?: Array<string>, direction?: IODirection, valueType?: IOValueType, group?: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<IODescription>> {
-            return localVarFp.listVirtualControllerIODescriptions(cell, controller, ios, direction, valueType, group, options).then((request) => request(axios, basePath));
+        listVirtualRobotIODescriptions(cell: string, controller: string, ios?: Array<string>, direction?: IODirection, valueType?: IOValueType, group?: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<IODescription>> {
+            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. 
@@ -14585,7 +14463,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.
@@ -14611,8 +14489,8 @@ export class VirtualControllerInputsOutputsApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof VirtualControllerInputsOutputsApi
      */
-    public listVirtualControllerIODescriptions(cell: string, controller: string, ios?: Array<string>, direction?: IODirection, valueType?: IOValueType, group?: string, options?: RawAxiosRequestConfig) {
-        return VirtualControllerInputsOutputsApiFp(this.configuration).listVirtualControllerIODescriptions(cell, controller, ios, direction, valueType, group, options).then((request) => request(this.axios, this.basePath));
+    public listVirtualRobotIODescriptions(cell: string, controller: string, ios?: Array<string>, direction?: IODirection, valueType?: IOValueType, group?: string, options?: RawAxiosRequestConfig) {
+        return VirtualControllerInputsOutputsApiFp(this.configuration).listVirtualRobotIODescriptions(cell, controller, ios, direction, valueType, group, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**