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

package/v2/api.js

@@ -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));
     }
 }
 /**