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

package/v2/api.ts

@@ -754,92 +754,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
@@ -1872,11 +1786,11 @@ export interface InvalidDofInvalidDof {
  */
 export interface InverseKinematicsRequest {
     /**
-     * The data to assemble the robot setup can be retrieved from [getMotionGroupDescription](getMotionGroupDescription) endpoint.
-     * @type {RobotSetup}
+     * String identifiying the model of a motion group.
+     * @type {string}
      * @memberof InverseKinematicsRequest
      */
-    'robot_setup': RobotSetup;
+    'motion_group_model': string;
     /**
      * List of TCP poses for which the inverse solutions are computed. 
      * @type {Array<Pose>}
@@ -1884,17 +1798,29 @@ export interface InverseKinematicsRequest {
      */
     'tcp_poses': Array<Pose>;
     /**
-     * A collection of identifiable colliders.
-     * @type {{ [key: string]: Collider; }}
+     * 
+     * @type {Pose}
      * @memberof InverseKinematicsRequest
      */
-    'static_colliders'?: { [key: string]: Collider; };
+    'tcp_offset'?: Pose;
+    /**
+     * Offset from the world frame to the motion group base.
+     * @type {Pose}
+     * @memberof InverseKinematicsRequest
+     */
+    'mounting'?: Pose;
     /**
-     * Collision motion group. 
-     * @type {CollisionMotionGroup}
+     * Joint position limits in [rad], indexed starting from base. 
+     * @type {Array<PlanningLimitsLimitRange>}
+     * @memberof InverseKinematicsRequest
+     */
+    'joint_position_limits'?: Array<PlanningLimitsLimitRange>;
+    /**
+     * Collision scenes to be respected by the motion planner. Each contains the single motion group which is planned for. Scenes are checked individually along the trajectory and independently of other scenes. To respect the safety zones of the controller, fetch the safety zones, link and tool shapes from the controller and add one scene made up of those. To respect the safety zones of the controller and check for collision: 1. Fetch the safety zones, link and tool shapes from the controller. 2. Add the fetched zones, links and tools to a scene. 3. Create other scenes from your own 3D data as needed. 4. Execute this endpoint. 5. The response highlights the scenes in which a collision was detected by key. 
+     * @type {{ [key: string]: SingleMotionGroupCollisionScene; }}
      * @memberof InverseKinematicsRequest
      */
-    'collision_motion_group'?: CollisionMotionGroup;
+    'collision_scenes'?: { [key: string]: SingleMotionGroupCollisionScene; };
 }
 /**
  * 
@@ -2566,49 +2492,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
@@ -3418,7 +3301,7 @@ export type PlaneShapeTypeEnum = typeof PlaneShapeTypeEnum[keyof typeof PlaneSha
  */
 export interface PlanningLimits {
     /**
-     * Joint position limits in [rad], configured in the safety setup, starting at base. 
+     * Joint position limits in [rad], indexed starting from base. 
      * @type {Array<PlanningLimitsLimitRange>}
      * @memberof PlanningLimits
      */
@@ -3954,11 +3837,11 @@ export interface RobotSetup {
      */
     'payload'?: Payload;
     /**
-     * Collision scenes to be respected by the motion planner. Each contains the single motion group which is planned for. Every scene is checked individually along the trajectory and independent of the other scenes. To respect the safety zones of the controller, fetch the safety zones, link and tool shapes from the controller and add one scene made up of those. 
-     * @type {Array<SingleMotionGroupCollisionScene>}
+     * Collision scenes to be respected by the motion planner. Each contains the single motion group which is planned for. Scenes are checked individually along the trajectory and independently of other scenes. To respect the safety zones of the controller, fetch the safety zones, link and tool shapes from the controller and add one scene made up of those. To respect the safety zones of the controller and check for collision: 1. Fetch the safety zones, link and tool shapes from the controller. 2. Add the fetched zones, links and tools to a scene. 3. Create other scenes from your own 3D data as needed. 4. Execute this endpoint. 5. The response highlights the scenes in which a collision was detected by key. 
+     * @type {{ [key: string]: SingleMotionGroupCollisionScene; }}
      * @memberof RobotSetup
      */
-    'collision_scenes'?: Array<SingleMotionGroupCollisionScene>;
+    'collision_scenes'?: { [key: string]: SingleMotionGroupCollisionScene; };
 }
 /**
  * Collection of information on the current state of the robot.
@@ -4235,17 +4118,23 @@ export interface SingleMotionGroupCollisionScene {
      */
     'static_colliders'?: { [key: string]: Collider; };
     /**
-     * The shape of the MotionGroups links to validate against static colliders. Indexed along the kinematic chain, starting with a static base shape before first joint. 
+     * A link chain is a kinematic chain of links that is connected via joints. A motion group can be used to control the motion of the joints in a link chain.  A link is a group of colliders that is attached to the link reference frame.  The reference frame of a link is obtained after applying all sets of Denavit-Hartenberg-parameters from base to (including) the link index.  This means that the reference frame of the link is on the rotation axis of the next joint in the kinematic chain. Example: For a motion group with 2 joints, the collider reference frame (CRF) for link 1 is on the rotation axis of joint 2. The chain looks like: - Origin >> Mounting >> Base >> (CRF Base) Joint 0 >> Link 0 >> (CRF Link 0) Joint 1 >> Link 1 >> (CRF Link 1) Flange (CRF Tool) >> TCP  Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. 
      * @type {Array<{ [key: string]: Collider; }>}
      * @memberof SingleMotionGroupCollisionScene
      */
     'link_chain'?: Array<{ [key: string]: Collider; }>;
     /**
-     * A collection of identifiable colliders.
+     * Defines the shape of a tool.  A tool is a dictionary of colliders.  All colliders that make up a tool are attached to the flange frame of the motion group. 
      * @type {{ [key: string]: Collider; }}
      * @memberof SingleMotionGroupCollisionScene
      */
     'tool'?: { [key: string]: Collider; };
+    /**
+     * If true, self-collision detection is enabled for the motion group. See LinkChain documentation for details. Default is true. 
+     * @type {boolean}
+     * @memberof SingleMotionGroupCollisionScene
+     */
+    'motion_group_self_collision_detection'?: boolean;
 }
 /**
  * 
@@ -4719,61 +4608,6 @@ export interface ValidationError2 {
  */
 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
@@ -6876,17 +6710,22 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
             };
         },
         /**
-         * 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: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        listCoordinateSystems: async (cell: string, controller: string, orientationType?: OrientationType, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // 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;
@@ -6906,6 +6745,10 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration)
 
+            if (orientationType !== undefined) {
+                localVarQueryParameter['orientation_type'] = orientationType;
+            }
+
 
     
             setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -6918,22 +6761,17 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
             };
         },
         /**
-         * 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: string, controller: string, orientationType?: OrientationType, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        listRobotControllers: async (cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // 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;
@@ -6953,10 +6791,6 @@ export const ControllerApiAxiosParamCreator = function (configuration?: Configur
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration)
 
-            if (orientationType !== undefined) {
-                localVarQueryParameter['orientation_type'] = orientationType;
-            }
-
 
     
             setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -7307,31 +7141,31 @@ export const ControllerApiFp = function(configuration?: 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: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ControllersList>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listControllers(cell, options);
+        async listCoordinateSystems(cell: string, controller: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListCoordinateSystemsResponse>> {
+            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: string, controller: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListCoordinateSystemsResponse>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listCoordinateSystems(cell, controller, orientationType, options);
+        async listRobotControllers(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<string>>> {
+            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);
         },
         /**
@@ -7497,16 +7331,6 @@ export const ControllerApiFactory = function (configuration?: Configuration, bas
         getVirtualRobotConfiguration(cell: string, controller: string, options?: RawAxiosRequestConfig): AxiosPromise<VirtualRobotConfiguration> {
             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: string, options?: RawAxiosRequestConfig): AxiosPromise<ControllersList> {
-            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
@@ -7519,6 +7343,16 @@ export const ControllerApiFactory = function (configuration?: Configuration, bas
         listCoordinateSystems(cell: string, controller: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig): AxiosPromise<ListCoordinateSystemsResponse> {
             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: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<string>> {
+            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
@@ -7687,29 +7521,29 @@ export class ControllerApi extends BaseAPI {
     }
 
     /**
-     * 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
      */
-    public listControllers(cell: string, options?: RawAxiosRequestConfig) {
-        return ControllerApiFp(this.configuration).listControllers(cell, options).then((request) => request(this.axios, this.basePath));
+    public listCoordinateSystems(cell: string, controller: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig) {
+        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
      */
-    public listCoordinateSystems(cell: string, controller: string, orientationType?: OrientationType, options?: RawAxiosRequestConfig) {
-        return ControllerApiFp(this.configuration).listCoordinateSystems(cell, controller, orientationType, options).then((request) => request(this.axios, this.basePath));
+    public listRobotControllers(cell: string, options?: RawAxiosRequestConfig) {
+        return ControllerApiFp(this.configuration).listRobotControllers(cell, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -8298,23 +8132,25 @@ export class ControllerInputsOutputsApi extends BaseAPI {
 
 
 /**
- * InverseKinematicsApi - axios parameter creator
+ * JoggingApi - axios parameter creator
  * @export
  */
-export const InverseKinematicsApiAxiosParamCreator = function (configuration?: Configuration) {
+export const JoggingApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
         /**
-         * Returns the reachable joint positions for a list of given poses. 
-         * @summary Inverse kinematics
+         * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP (Tool Center Point). The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send InitializeJoggingRequest to configure the jogging.  Sets robot controller mode to control mode. Sets rate and coordinate system for the jogging response.  #### 2. Send JointVelocityRequest or TcpVelocityRequest to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with JointVelocityRequest or TcpVelocityRequest. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - InitializeJoggingResponse is sent to signal the success or failure of the InitializeJoggingRequest. - Jogging responses are streamed continuously after an InitializeJoggingRequest is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - JoggingErrorResponse with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the JoggingResponse, verify that the robot control is in the desired state, e.g. standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. 
+         * @summary Execute Jogging
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {InverseKinematicsRequest} [inverseKinematicsRequest] 
+         * @param {ExecuteJoggingRequest} executeJoggingRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        inverseKinematics: async (cell: string, inverseKinematicsRequest?: InverseKinematicsRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        executeJogging: async (cell: string, executeJoggingRequest: ExecuteJoggingRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('inverseKinematics', 'cell', cell)
-            const localVarPath = `/cells/{cell}/kinematic/inverse-kinematics`
+            assertParamExists('executeJogging', 'cell', cell)
+            // verify required parameter 'executeJoggingRequest' is not null or undefined
+            assertParamExists('executeJogging', 'executeJoggingRequest', executeJoggingRequest)
+            const localVarPath = `/cells/{cell}/execution/jogging`
                 .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);
@@ -8323,7 +8159,7 @@ export const InverseKinematicsApiAxiosParamCreator = function (configuration?: C
                 baseOptions = configuration.baseOptions;
             }
 
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
             const localVarHeaderParameter = {} as any;
             const localVarQueryParameter = {} as any;
 
@@ -8342,7 +8178,7 @@ export const InverseKinematicsApiAxiosParamCreator = function (configuration?: C
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-            localVarRequestOptions.data = serializeDataIfNeeded(inverseKinematicsRequest, localVarRequestOptions, configuration)
+            localVarRequestOptions.data = serializeDataIfNeeded(executeJoggingRequest, localVarRequestOptions, configuration)
 
             return {
                 url: toPathString(localVarUrlObj),
@@ -8353,93 +8189,91 @@ export const InverseKinematicsApiAxiosParamCreator = function (configuration?: C
 };
 
 /**
- * InverseKinematicsApi - functional programming interface
+ * JoggingApi - functional programming interface
  * @export
  */
-export const InverseKinematicsApiFp = function(configuration?: Configuration) {
-    const localVarAxiosParamCreator = InverseKinematicsApiAxiosParamCreator(configuration)
+export const JoggingApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = JoggingApiAxiosParamCreator(configuration)
     return {
         /**
-         * Returns the reachable joint positions for a list of given poses. 
-         * @summary Inverse kinematics
+         * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP (Tool Center Point). The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send InitializeJoggingRequest to configure the jogging.  Sets robot controller mode to control mode. Sets rate and coordinate system for the jogging response.  #### 2. Send JointVelocityRequest or TcpVelocityRequest to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with JointVelocityRequest or TcpVelocityRequest. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - InitializeJoggingResponse is sent to signal the success or failure of the InitializeJoggingRequest. - Jogging responses are streamed continuously after an InitializeJoggingRequest is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - JoggingErrorResponse with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the JoggingResponse, verify that the robot control is in the desired state, e.g. standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. 
+         * @summary Execute Jogging
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {InverseKinematicsRequest} [inverseKinematicsRequest] 
+         * @param {ExecuteJoggingRequest} executeJoggingRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async inverseKinematics(cell: string, inverseKinematicsRequest?: InverseKinematicsRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<InverseKinematicsResponse>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.inverseKinematics(cell, inverseKinematicsRequest, options);
+        async executeJogging(cell: string, executeJoggingRequest: ExecuteJoggingRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ExecuteJoggingResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.executeJogging(cell, executeJoggingRequest, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['InverseKinematicsApi.inverseKinematics']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['JoggingApi.executeJogging']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     }
 };
 
 /**
- * InverseKinematicsApi - factory interface
+ * JoggingApi - factory interface
  * @export
  */
-export const InverseKinematicsApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
-    const localVarFp = InverseKinematicsApiFp(configuration)
+export const JoggingApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
+    const localVarFp = JoggingApiFp(configuration)
     return {
         /**
-         * Returns the reachable joint positions for a list of given poses. 
-         * @summary Inverse kinematics
+         * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP (Tool Center Point). The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send InitializeJoggingRequest to configure the jogging.  Sets robot controller mode to control mode. Sets rate and coordinate system for the jogging response.  #### 2. Send JointVelocityRequest or TcpVelocityRequest to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with JointVelocityRequest or TcpVelocityRequest. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - InitializeJoggingResponse is sent to signal the success or failure of the InitializeJoggingRequest. - Jogging responses are streamed continuously after an InitializeJoggingRequest is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - JoggingErrorResponse with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the JoggingResponse, verify that the robot control is in the desired state, e.g. standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. 
+         * @summary Execute Jogging
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {InverseKinematicsRequest} [inverseKinematicsRequest] 
+         * @param {ExecuteJoggingRequest} executeJoggingRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        inverseKinematics(cell: string, inverseKinematicsRequest?: InverseKinematicsRequest, options?: RawAxiosRequestConfig): AxiosPromise<InverseKinematicsResponse> {
-            return localVarFp.inverseKinematics(cell, inverseKinematicsRequest, options).then((request) => request(axios, basePath));
+        executeJogging(cell: string, executeJoggingRequest: ExecuteJoggingRequest, options?: RawAxiosRequestConfig): AxiosPromise<ExecuteJoggingResponse> {
+            return localVarFp.executeJogging(cell, executeJoggingRequest, options).then((request) => request(axios, basePath));
         },
     };
 };
 
 /**
- * InverseKinematicsApi - object-oriented interface
+ * JoggingApi - object-oriented interface
  * @export
- * @class InverseKinematicsApi
+ * @class JoggingApi
  * @extends {BaseAPI}
  */
-export class InverseKinematicsApi extends BaseAPI {
+export class JoggingApi extends BaseAPI {
     /**
-     * Returns the reachable joint positions for a list of given poses. 
-     * @summary Inverse kinematics
+     * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP (Tool Center Point). The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send InitializeJoggingRequest to configure the jogging.  Sets robot controller mode to control mode. Sets rate and coordinate system for the jogging response.  #### 2. Send JointVelocityRequest or TcpVelocityRequest to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with JointVelocityRequest or TcpVelocityRequest. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - InitializeJoggingResponse is sent to signal the success or failure of the InitializeJoggingRequest. - Jogging responses are streamed continuously after an InitializeJoggingRequest is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - JoggingErrorResponse with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the JoggingResponse, verify that the robot control is in the desired state, e.g. standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. 
+     * @summary Execute Jogging
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {InverseKinematicsRequest} [inverseKinematicsRequest] 
+     * @param {ExecuteJoggingRequest} executeJoggingRequest 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof InverseKinematicsApi
+     * @memberof JoggingApi
      */
-    public inverseKinematics(cell: string, inverseKinematicsRequest?: InverseKinematicsRequest, options?: RawAxiosRequestConfig) {
-        return InverseKinematicsApiFp(this.configuration).inverseKinematics(cell, inverseKinematicsRequest, options).then((request) => request(this.axios, this.basePath));
+    public executeJogging(cell: string, executeJoggingRequest: ExecuteJoggingRequest, options?: RawAxiosRequestConfig) {
+        return JoggingApiFp(this.configuration).executeJogging(cell, executeJoggingRequest, options).then((request) => request(this.axios, this.basePath));
     }
 }
 
 
 
 /**
- * JoggingApi - axios parameter creator
+ * KinematicsApi - axios parameter creator
  * @export
  */
-export const JoggingApiAxiosParamCreator = function (configuration?: Configuration) {
+export const KinematicsApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
         /**
-         * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP (Tool Center Point). The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send InitializeJoggingRequest to configure the jogging.  Sets robot controller mode to control mode. Sets rate and coordinate system for the jogging response.  #### 2. Send JointVelocityRequest or TcpVelocityRequest to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with JointVelocityRequest or TcpVelocityRequest. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - InitializeJoggingResponse is sent to signal the success or failure of the InitializeJoggingRequest. - Jogging responses are streamed continuously after an InitializeJoggingRequest is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - JoggingErrorResponse with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the JoggingResponse, verify that the robot control is in the desired state, e.g. standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. 
-         * @summary Execute Jogging
+         * Returns the reachable joint positions for a list of given poses. 
+         * @summary Inverse kinematics
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {ExecuteJoggingRequest} executeJoggingRequest 
+         * @param {InverseKinematicsRequest} [inverseKinematicsRequest] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        executeJogging: async (cell: string, executeJoggingRequest: ExecuteJoggingRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        inverseKinematics: async (cell: string, inverseKinematicsRequest?: InverseKinematicsRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('executeJogging', 'cell', cell)
-            // verify required parameter 'executeJoggingRequest' is not null or undefined
-            assertParamExists('executeJogging', 'executeJoggingRequest', executeJoggingRequest)
-            const localVarPath = `/cells/{cell}/execution/jogging`
+            assertParamExists('inverseKinematics', 'cell', cell)
+            const localVarPath = `/cells/{cell}/kinematic/inverse`
                 .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);
@@ -8448,7 +8282,7 @@ export const JoggingApiAxiosParamCreator = function (configuration?: Configurati
                 baseOptions = configuration.baseOptions;
             }
 
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
             const localVarHeaderParameter = {} as any;
             const localVarQueryParameter = {} as any;
 
@@ -8467,7 +8301,7 @@ export const JoggingApiAxiosParamCreator = function (configuration?: Configurati
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-            localVarRequestOptions.data = serializeDataIfNeeded(executeJoggingRequest, localVarRequestOptions, configuration)
+            localVarRequestOptions.data = serializeDataIfNeeded(inverseKinematicsRequest, localVarRequestOptions, configuration)
 
             return {
                 url: toPathString(localVarUrlObj),
@@ -8478,68 +8312,68 @@ export const JoggingApiAxiosParamCreator = function (configuration?: Configurati
 };
 
 /**
- * JoggingApi - functional programming interface
+ * KinematicsApi - functional programming interface
  * @export
  */
-export const JoggingApiFp = function(configuration?: Configuration) {
-    const localVarAxiosParamCreator = JoggingApiAxiosParamCreator(configuration)
+export const KinematicsApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = KinematicsApiAxiosParamCreator(configuration)
     return {
         /**
-         * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP (Tool Center Point). The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send InitializeJoggingRequest to configure the jogging.  Sets robot controller mode to control mode. Sets rate and coordinate system for the jogging response.  #### 2. Send JointVelocityRequest or TcpVelocityRequest to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with JointVelocityRequest or TcpVelocityRequest. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - InitializeJoggingResponse is sent to signal the success or failure of the InitializeJoggingRequest. - Jogging responses are streamed continuously after an InitializeJoggingRequest is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - JoggingErrorResponse with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the JoggingResponse, verify that the robot control is in the desired state, e.g. standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. 
-         * @summary Execute Jogging
+         * Returns the reachable joint positions for a list of given poses. 
+         * @summary Inverse kinematics
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {ExecuteJoggingRequest} executeJoggingRequest 
+         * @param {InverseKinematicsRequest} [inverseKinematicsRequest] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async executeJogging(cell: string, executeJoggingRequest: ExecuteJoggingRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ExecuteJoggingResponse>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.executeJogging(cell, executeJoggingRequest, options);
+        async inverseKinematics(cell: string, inverseKinematicsRequest?: InverseKinematicsRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<InverseKinematicsResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.inverseKinematics(cell, inverseKinematicsRequest, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['JoggingApi.executeJogging']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['KinematicsApi.inverseKinematics']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     }
 };
 
 /**
- * JoggingApi - factory interface
+ * KinematicsApi - factory interface
  * @export
  */
-export const JoggingApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
-    const localVarFp = JoggingApiFp(configuration)
+export const KinematicsApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
+    const localVarFp = KinematicsApiFp(configuration)
     return {
         /**
-         * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP (Tool Center Point). The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send InitializeJoggingRequest to configure the jogging.  Sets robot controller mode to control mode. Sets rate and coordinate system for the jogging response.  #### 2. Send JointVelocityRequest or TcpVelocityRequest to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with JointVelocityRequest or TcpVelocityRequest. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - InitializeJoggingResponse is sent to signal the success or failure of the InitializeJoggingRequest. - Jogging responses are streamed continuously after an InitializeJoggingRequest is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - JoggingErrorResponse with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the JoggingResponse, verify that the robot control is in the desired state, e.g. standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. 
-         * @summary Execute Jogging
+         * Returns the reachable joint positions for a list of given poses. 
+         * @summary Inverse kinematics
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {ExecuteJoggingRequest} executeJoggingRequest 
+         * @param {InverseKinematicsRequest} [inverseKinematicsRequest] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        executeJogging(cell: string, executeJoggingRequest: ExecuteJoggingRequest, options?: RawAxiosRequestConfig): AxiosPromise<ExecuteJoggingResponse> {
-            return localVarFp.executeJogging(cell, executeJoggingRequest, options).then((request) => request(axios, basePath));
+        inverseKinematics(cell: string, inverseKinematicsRequest?: InverseKinematicsRequest, options?: RawAxiosRequestConfig): AxiosPromise<InverseKinematicsResponse> {
+            return localVarFp.inverseKinematics(cell, inverseKinematicsRequest, options).then((request) => request(axios, basePath));
         },
     };
 };
 
 /**
- * JoggingApi - object-oriented interface
+ * KinematicsApi - object-oriented interface
  * @export
- * @class JoggingApi
+ * @class KinematicsApi
  * @extends {BaseAPI}
  */
-export class JoggingApi extends BaseAPI {
+export class KinematicsApi extends BaseAPI {
     /**
-     * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a dynamically adaptable jogging motion for a motion group.  Jogging describes controlling a motion group by sending real-time commands to move either its joints or the TCP (Tool Center Point). The commands contain target velocities that may change at any time during execution, so the resulting motion cannot be computed upfront.  ### Preconditions  The motion group is not moved by any other endpoint.  ### Requests  #### 1. Send InitializeJoggingRequest to configure the jogging.  Sets robot controller mode to control mode. Sets rate and coordinate system for the jogging response.  #### 2. Send JointVelocityRequest or TcpVelocityRequest to start the jogging motion.  #### 3. Change or stop the jogging motion  - Change the jogging direction and/or velocity during the jogging motion with JointVelocityRequest or TcpVelocityRequest. - To stop the jogging motion, send zero velocities via either request.  ### Responses  - InitializeJoggingResponse is sent to signal the success or failure of the InitializeJoggingRequest. - Jogging responses are streamed continuously after an InitializeJoggingRequest is processed.   Jogging responses contain the robot controller state and the state of the jogging control. - JoggingErrorResponse with error details is sent in case of an unexpected error, e.g., controller disconnects during jogging.  ### Tips and Tricks  - In the JoggingResponse, verify that the robot control is in the desired state, e.g. standstill, with JoggingState. - Ensure that the websocket connection remains open until the jogging motion is stopped to avoid unexpected stops. 
-     * @summary Execute Jogging
+     * Returns the reachable joint positions for a list of given poses. 
+     * @summary Inverse kinematics
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {ExecuteJoggingRequest} executeJoggingRequest 
+     * @param {InverseKinematicsRequest} [inverseKinematicsRequest] 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof JoggingApi
+     * @memberof KinematicsApi
      */
-    public executeJogging(cell: string, executeJoggingRequest: ExecuteJoggingRequest, options?: RawAxiosRequestConfig) {
-        return JoggingApiFp(this.configuration).executeJogging(cell, executeJoggingRequest, options).then((request) => request(this.axios, this.basePath));
+    public inverseKinematics(cell: string, inverseKinematicsRequest?: InverseKinematicsRequest, options?: RawAxiosRequestConfig) {
+        return KinematicsApiFp(this.configuration).inverseKinematics(cell, inverseKinematicsRequest, options).then((request) => request(this.axios, this.basePath));
     }
 }