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

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.
@@ -3494,23 +3494,25 @@ export class ControllerInputsOutputsApi extends BaseAPI {
     }
 }
 /**
- * InverseKinematicsApi - axios parameter creator
+ * JoggingApi - axios parameter creator
  * @export
  */
-export const InverseKinematicsApiAxiosParamCreator = function (configuration) {
+export const JoggingApiAxiosParamCreator = function (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, inverseKinematicsRequest, options = {}) => {
+        executeJogging: async (cell, executeJoggingRequest, options = {}) => {
             // 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);
@@ -3518,7 +3520,7 @@ export const InverseKinematicsApiAxiosParamCreator = function (configuration) {
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -3531,7 +3533,7 @@ export const InverseKinematicsApiAxiosParamCreator = function (configuration) {
             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),
                 options: localVarRequestOptions,
@@ -3540,88 +3542,86 @@ export const InverseKinematicsApiAxiosParamCreator = function (configuration) {
     };
 };
 /**
- * InverseKinematicsApi - functional programming interface
+ * JoggingApi - functional programming interface
  * @export
  */
-export const InverseKinematicsApiFp = function (configuration) {
-    const localVarAxiosParamCreator = InverseKinematicsApiAxiosParamCreator(configuration);
+export const JoggingApiFp = function (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, inverseKinematicsRequest, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.inverseKinematics(cell, inverseKinematicsRequest, options);
+        async executeJogging(cell, executeJoggingRequest, options) {
+            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, basePath, axios) {
-    const localVarFp = InverseKinematicsApiFp(configuration);
+export const JoggingApiFactory = function (configuration, basePath, axios) {
+    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, inverseKinematicsRequest, options) {
-            return localVarFp.inverseKinematics(cell, inverseKinematicsRequest, options).then((request) => request(axios, basePath));
+        executeJogging(cell, executeJoggingRequest, options) {
+            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
      */
-    inverseKinematics(cell, inverseKinematicsRequest, options) {
-        return InverseKinematicsApiFp(this.configuration).inverseKinematics(cell, inverseKinematicsRequest, options).then((request) => request(this.axios, this.basePath));
+    executeJogging(cell, executeJoggingRequest, options) {
+        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) {
+export const KinematicsApiAxiosParamCreator = function (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, executeJoggingRequest, options = {}) => {
+        inverseKinematics: async (cell, inverseKinematicsRequest, options = {}) => {
             // 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);
@@ -3629,7 +3629,7 @@ export const JoggingApiAxiosParamCreator = function (configuration) {
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -3642,7 +3642,7 @@ export const JoggingApiAxiosParamCreator = function (configuration) {
             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),
                 options: localVarRequestOptions,
@@ -3651,66 +3651,66 @@ export const JoggingApiAxiosParamCreator = function (configuration) {
     };
 };
 /**
- * JoggingApi - functional programming interface
+ * KinematicsApi - functional programming interface
  * @export
  */
-export const JoggingApiFp = function (configuration) {
-    const localVarAxiosParamCreator = JoggingApiAxiosParamCreator(configuration);
+export const KinematicsApiFp = function (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, executeJoggingRequest, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.executeJogging(cell, executeJoggingRequest, options);
+        async inverseKinematics(cell, inverseKinematicsRequest, options) {
+            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, basePath, axios) {
-    const localVarFp = JoggingApiFp(configuration);
+export const KinematicsApiFactory = function (configuration, basePath, axios) {
+    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, executeJoggingRequest, options) {
-            return localVarFp.executeJogging(cell, executeJoggingRequest, options).then((request) => request(axios, basePath));
+        inverseKinematics(cell, inverseKinematicsRequest, options) {
+            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
      */
-    executeJogging(cell, executeJoggingRequest, options) {
-        return JoggingApiFp(this.configuration).executeJogging(cell, executeJoggingRequest, options).then((request) => request(this.axios, this.basePath));
+    inverseKinematics(cell, inverseKinematicsRequest, options) {
+        return KinematicsApiFp(this.configuration).inverseKinematics(cell, inverseKinematicsRequest, options).then((request) => request(this.axios, this.basePath));
     }
 }
 /**