@wandelbots/nova-api 25.6.0-dev.30 → 25.6.0-dev.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wandelbots/nova-api",
-  "version": "25.6.0-dev.30",
+  "version": "25.6.0-dev.31",
   "description": "API Client to interact with Wandelbots Public API.",
   "files": [
     "*",

package/v2/api.d.ts

@@ -747,92 +747,6 @@ export interface ContainerStorage {
      */
     'capacity': string;
 }
-/**
- * The data type to describe a robot controller.
- * @export
- * @interface Controller
- */
-export interface Controller {
-    /**
-     * The unique identifier to address the robot controller in the cell.
-     * @type {string}
-     * @memberof Controller
-     */
-    'controller': string;
-    /**
-     * The unique identifier to address a robot controller model when configuring the robot controller. Used for evaluation of the robot controller model and to ensure communication with the expected robot controller type.
-     * @type {string}
-     * @memberof Controller
-     */
-    'model_name': string;
-    /**
-     * Resolvable host name or IP address that connects to the robot controller.
-     * @type {string}
-     * @memberof Controller
-     */
-    'host': string;
-    /**
-     * True if the user has actively confirmed that it is allowed to install required communication software onto the robot controller.  NOTE: Installing third party software on a robot controller can result in liability issues in regard to the actual certified state of the robot system. Please contact your company\'s legal responsible before installing third party software.
-     * @type {boolean}
-     * @memberof Controller
-     */
-    'allow_software_install_on_controller': boolean;
-    /**
-     * The list of physical connected motion groups as detected by the controller.
-     * @type {Array<MotionGroupInstance>}
-     * @memberof Controller
-     */
-    'motion_groups': Array<MotionGroupInstance>;
-    /**
-     *
-     * @type {VersionNumber}
-     * @memberof Controller
-     */
-    'vendor_software_version'?: VersionNumber;
-    /**
-     * Set to true if there was an error while inspecting this instance, e.g. The robot controller is not reachable due to missing network connection or turned off.  The instance remains configured but can\'t provide information on the robot controller.
-     * @type {boolean}
-     * @memberof Controller
-     */
-    'has_error': boolean;
-    /**
-     * If has_error is true, error_details provides detailed background information about the error.
-     * @type {string}
-     * @memberof Controller
-     */
-    'error_details'?: string;
-    /**
-     * Can this controller be moved through freedrive (true), or not (false).
-     * @type {boolean}
-     * @memberof Controller
-     */
-    'supports_freedrive': boolean;
-    /**
-     * Can this controller be controlled with NOVA (true) or is it only possible to read data (false).
-     * @type {boolean}
-     * @memberof Controller
-     */
-    '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 not guarantuee that the executed motions respect safety zones defined by the controller.
-     * @type {boolean}
-     * @memberof Controller
-     */
-    'supports_safety_zones': boolean;
-}
-/**
- * The list of configured robot controllers.
- * @export
- * @interface ControllersList
- */
-export interface ControllersList {
-    /**
-     *
-     * @type {Array<Controller>}
-     * @memberof ControllersList
-     */
-    'controllers': Array<Controller>;
-}
 /**
  * Defines a convex hull encapsulating a set of vertices.
  * @export
@@ -2503,49 +2417,6 @@ export interface MotionGroupInfos {
      */
     'motion_groups': Array<MotionGroupInfo>;
 }
-/**
- * The data type describes the physically connected motion groups on a robot controller, e.g., a robot arm.
- * @export
- * @interface MotionGroupInstance
- */
-export interface MotionGroupInstance {
-    /**
-     * Identifier of the motion group.
-     * @type {string}
-     * @memberof MotionGroupInstance
-     */
-    'motion_group': string;
-    /**
-     * Identifier of the robot controller the motion group is attached to.
-     * @type {string}
-     * @memberof MotionGroupInstance
-     */
-    'controller': string;
-    /**
-     * The name of the motion group has on the robot controller.
-     * @type {string}
-     * @memberof MotionGroupInstance
-     */
-    'name_from_controller': string;
-    /**
-     * The robot controller model, if available. Usable for frontend 3D visualization.
-     * @type {string}
-     * @memberof MotionGroupInstance
-     */
-    'model_from_controller': string;
-    /**
-     * The serial number of the motion group, if available. If not available, the serial number of the robot controller. if available. If not available, then empty.
-     * @type {string}
-     * @memberof MotionGroupInstance
-     */
-    'serial_number'?: string;
-    /**
-     * True if NOVA supports inverse kinematics for this motion group. Inverse kinematics is used to calculate the joint angles from the end effector position. If inverse kinematics is not supported, cartesian jogging is not possible.
-     * @type {boolean}
-     * @memberof MotionGroupInstance
-     */
-    'has_inverse_kinematics': boolean;
-}
 /**
  * Ensure to provide one value for each joint. See [getMotionGroups](getMotionGroups) for the number of joints. Everything but positions is optional.
  * @export
@@ -4527,61 +4398,6 @@ export interface ValidationError2 {
  * @export
  */
 export type ValidationErrorLocInner = number | string;
-/**
- * A generic representation of a version number.
- * @export
- * @interface VersionNumber
- */
-export interface VersionNumber {
-    /**
-     *
-     * @type {number}
-     * @memberof VersionNumber
-     */
-    'major_version': number;
-    /**
-     *
-     * @type {number}
-     * @memberof VersionNumber
-     */
-    'minor_version'?: number;
-    /**
-     *
-     * @type {number}
-     * @memberof VersionNumber
-     */
-    'build_version'?: number;
-    /**
-     *
-     * @type {number}
-     * @memberof VersionNumber
-     */
-    'bugfix_version'?: number;
-    /**
-     * If minor version is a wildcard set to true.
-     * @type {boolean}
-     * @memberof VersionNumber
-     */
-    'minor_version_wildcard'?: boolean;
-    /**
-     * If build version is a wildcard set to true.
-     * @type {boolean}
-     * @memberof VersionNumber
-     */
-    'build_version_wildcard'?: boolean;
-    /**
-     * If bugfix version is a wildcard set to true.
-     * @type {boolean}
-     * @memberof VersionNumber
-     */
-    'bugfix_version_wildcard'?: boolean;
-    /**
-     * A string representation of the version e.g. 1.1.x.x.
-     * @type {string}
-     * @memberof VersionNumber
-     */
-    'string_version'?: string;
-}
 /**
  * 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
@@ -5546,14 +5362,6 @@ export declare const ControllerApiAxiosParamCreator: (configuration?: Configurat
      * @throws {RequiredError}
      */
     getVirtualRobotConfiguration: (cell: string, controller: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
-    /**
-     * List all configured robot controllers.
-     * @summary List Descriptions
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    listControllers: (cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
      * 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.
      * @summary List Coordinate Systems
@@ -5564,6 +5372,14 @@ export declare const ControllerApiAxiosParamCreator: (configuration?: Configurat
      * @throws {RequiredError}
      */
     listCoordinateSystems: (cell: string, controller: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
+    /**
+     * List the names of all deployed robot controllers.
+     * @summary List Robot Controllers
+     * @param {string} cell Unique identifier addressing a cell in all API calls.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listRobotControllers: (cell: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
      * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change.
      * @summary Set Default Mode
@@ -5687,14 +5503,6 @@ export declare const ControllerApiFp: (configuration?: Configuration) => {
      * @throws {RequiredError}
      */
     getVirtualRobotConfiguration(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VirtualRobotConfiguration>>;
-    /**
-     * List all configured robot controllers.
-     * @summary List Descriptions
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    listControllers(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ControllersList>>;
     /**
      * 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.
      * @summary List Coordinate Systems
@@ -5705,6 +5513,14 @@ export declare const ControllerApiFp: (configuration?: Configuration) => {
      * @throws {RequiredError}
      */
     listCoordinateSystems(cell: string, controller: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListCoordinateSystemsResponse>>;
+    /**
+     * List the names of all deployed robot controllers.
+     * @summary List Robot Controllers
+     * @param {string} cell Unique identifier addressing a cell in all API calls.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listRobotControllers(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<string>>>;
     /**
      * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change.
      * @summary Set Default Mode
@@ -5828,14 +5644,6 @@ export declare const ControllerApiFactory: (configuration?: Configuration, baseP
      * @throws {RequiredError}
      */
     getVirtualRobotConfiguration(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<VirtualRobotConfiguration>;
-    /**
-     * List all configured robot controllers.
-     * @summary List Descriptions
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    listControllers(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<ControllersList>;
     /**
      * 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.
      * @summary List Coordinate Systems
@@ -5846,6 +5654,14 @@ export declare const ControllerApiFactory: (configuration?: Configuration, baseP
      * @throws {RequiredError}
      */
     listCoordinateSystems(cell: string, controller: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig): AxiosPromise<ListCoordinateSystemsResponse>;
+    /**
+     * List the names of all deployed robot controllers.
+     * @summary List Robot Controllers
+     * @param {string} cell Unique identifier addressing a cell in all API calls.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listRobotControllers(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<string>>;
     /**
      * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change.
      * @summary Set Default Mode
@@ -5980,25 +5796,25 @@ export declare class ControllerApi extends BaseAPI {
      */
     getVirtualRobotConfiguration(cell: string, controller: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VirtualRobotConfiguration, any>>;
     /**
-     * List all configured robot controllers.
-     * @summary List Descriptions
+     * 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.
+     * @summary List Coordinate Systems
      * @param {string} cell Unique identifier addressing a cell in all API calls.
+     * @param {string} controller Unique identifier to address a controller in the cell.
+     * @param {OrientationType} [orientationType]
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ControllerApi
      */
-    listControllers(cell: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ControllersList, any>>;
+    listCoordinateSystems(cell: string, controller: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ListCoordinateSystemsResponse, any>>;
     /**
-     * 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.
-     * @summary List Coordinate Systems
+     * List the names of all deployed robot controllers.
+     * @summary List Robot Controllers
      * @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 {OrientationType} [orientationType]
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ControllerApi
      */
-    listCoordinateSystems(cell: string, controller: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ListCoordinateSystemsResponse, any>>;
+    listRobotControllers(cell: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<string[], any>>;
     /**
      * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change.
      * @summary Set Default Mode

package/v2/api.js

@@ -2192,17 +2192,22 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * List all configured robot controllers.
-         * @summary List Descriptions
+         * 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.
+         * @summary List Coordinate Systems
          * @param {string} cell Unique identifier addressing a cell in all API calls.
+         * @param {string} controller Unique identifier to address a controller in the cell.
+         * @param {OrientationType} [orientationType]
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listControllers: async (cell, options = {}) => {
+        listCoordinateSystems: async (cell, controller, orientationType, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('listControllers', 'cell', cell);
-            const localVarPath = `/cells/{cell}/controllers`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
+            assertParamExists('listCoordinateSystems', 'cell', cell);
+            // verify required parameter 'controller' is not null or undefined
+            assertParamExists('listCoordinateSystems', 'controller', controller);
+            const localVarPath = `/cells/{cell}/controllers/{controller}/coordinate-systems`
+                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
+                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -2218,6 +2223,9 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            if (orientationType !== undefined) {
+                localVarQueryParameter['orientation_type'] = orientationType;
+            }
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -2227,22 +2235,17 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * 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.
-         * @summary List Coordinate Systems
+         * List the names of all deployed robot controllers.
+         * @summary List Robot Controllers
          * @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 {OrientationType} [orientationType]
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listCoordinateSystems: async (cell, controller, orientationType, options = {}) => {
+        listRobotControllers: async (cell, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('listCoordinateSystems', 'cell', cell);
-            // verify required parameter 'controller' is not null or undefined
-            assertParamExists('listCoordinateSystems', 'controller', controller);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/coordinate-systems`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
+            assertParamExists('listRobotControllers', 'cell', cell);
+            const localVarPath = `/cells/{cell}/controllers`
+                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -2258,9 +2261,6 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (orientationType !== undefined) {
-                localVarQueryParameter['orientation_type'] = orientationType;
-            }
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -2574,31 +2574,31 @@ export const ControllerApiFp = function (configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * List all configured robot controllers.
-         * @summary List Descriptions
+         * 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.
+         * @summary List Coordinate Systems
          * @param {string} cell Unique identifier addressing a cell in all API calls.
+         * @param {string} controller Unique identifier to address a controller in the cell.
+         * @param {OrientationType} [orientationType]
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async listControllers(cell, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listControllers(cell, options);
+        async listCoordinateSystems(cell, controller, orientationType, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listCoordinateSystems(cell, controller, orientationType, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ControllerApi.listControllers']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['ControllerApi.listCoordinateSystems']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || 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.
-         * @summary List Coordinate Systems
+         * List the names of all deployed robot controllers.
+         * @summary List Robot Controllers
          * @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 {OrientationType} [orientationType]
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async listCoordinateSystems(cell, controller, orientationType, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listCoordinateSystems(cell, controller, orientationType, options);
+        async listRobotControllers(cell, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listRobotControllers(cell, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ControllerApi.listCoordinateSystems']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['ControllerApi.listRobotControllers']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -2763,16 +2763,6 @@ export const ControllerApiFactory = function (configuration, basePath, axios) {
         getVirtualRobotConfiguration(cell, controller, options) {
             return localVarFp.getVirtualRobotConfiguration(cell, controller, options).then((request) => request(axios, basePath));
         },
-        /**
-         * List all configured robot controllers.
-         * @summary List Descriptions
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        listControllers(cell, options) {
-            return localVarFp.listControllers(cell, 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.
          * @summary List Coordinate Systems
@@ -2785,6 +2775,16 @@ export const ControllerApiFactory = function (configuration, basePath, axios) {
         listCoordinateSystems(cell, controller, orientationType, options) {
             return localVarFp.listCoordinateSystems(cell, controller, orientationType, options).then((request) => request(axios, basePath));
         },
+        /**
+         * List the names of all deployed robot controllers.
+         * @summary List Robot Controllers
+         * @param {string} cell Unique identifier addressing a cell in all API calls.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listRobotControllers(cell, options) {
+            return localVarFp.listRobotControllers(cell, options).then((request) => request(axios, basePath));
+        },
         /**
          * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change.
          * @summary Set Default Mode
@@ -2944,28 +2944,28 @@ export class ControllerApi extends BaseAPI {
         return ControllerApiFp(this.configuration).getVirtualRobotConfiguration(cell, controller, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * List all configured robot controllers.
-     * @summary List Descriptions
+     * 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.
+     * @summary List Coordinate Systems
      * @param {string} cell Unique identifier addressing a cell in all API calls.
+     * @param {string} controller Unique identifier to address a controller in the cell.
+     * @param {OrientationType} [orientationType]
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ControllerApi
      */
-    listControllers(cell, options) {
-        return ControllerApiFp(this.configuration).listControllers(cell, options).then((request) => request(this.axios, this.basePath));
+    listCoordinateSystems(cell, controller, orientationType, options) {
+        return ControllerApiFp(this.configuration).listCoordinateSystems(cell, controller, orientationType, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Lists all specifications of coordinate systems from robot controllers. Use parameter orientation_type to get the orientation part of the transformation offset of the coordinate system returned in the requested orientation notation. If parameter orientation_type is not set, the orientation part of the transformation offset of the coordinate system is returned in rotation vector notation.  The coordinate systems from the robot controller are loaded when the motion group associated with the coordinate system is activated. With deactivation of the motion group, the associated coordinate systems are removed from NOVA. The unique identifier of the coordinate systems from the robot controllers are suffixed with \"On\" + the unique identifier of the robot controller.
-     * @summary List Coordinate Systems
+     * List the names of all deployed robot controllers.
+     * @summary List Robot Controllers
      * @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 {OrientationType} [orientationType]
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ControllerApi
      */
-    listCoordinateSystems(cell, controller, orientationType, options) {
-        return ControllerApiFp(this.configuration).listCoordinateSystems(cell, controller, orientationType, options).then((request) => request(this.axios, this.basePath));
+    listRobotControllers(cell, options) {
+        return ControllerApiFp(this.configuration).listRobotControllers(cell, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * Switch between monitor and control usage as default for a robot controller. Monitoring mode is used to read information from the robot controller and control mode is used to command the robot system. As long as the robot controller is connected via network monitoring mode is always possible. To switch to control mode the robot controller must be in `automatic` or `manual` operating mode and safety state \'normal\' or \'reduced\'. If the robot controller is in `manual` operating mode, you have manually confirm the control usage activation on the robot control panel. This manual confirmation can\'t be replaced with this API. Without manual confirmation the robot controller will stay in monitor mode.  The robot system will try to activate the required operation mode for the requested usage unless no active call requires a different mode.  > **NOTE** > > Some robot controllers prevent the external activation of automatic operating mode. In this case, changing the operating mode manually at the robot controller is mandatory.  > **NOTE** > > The current operation mode and safety state can be requested via [getCurrentRobotControllerState](getCurrentRobotControllerState).  If a mode change is not possible, the response lists reasons for the failed change.