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

package/v2/api.ts

@@ -1786,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>}
@@ -1798,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;
     /**
-     * Collision motion group. 
-     * @type {CollisionMotionGroup}
+     * Offset from the world frame to the motion group base.
+     * @type {Pose}
      * @memberof InverseKinematicsRequest
      */
-    'collision_motion_group'?: CollisionMotionGroup;
+    'mounting'?: Pose;
+    /**
+     * 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_scenes'?: { [key: string]: SingleMotionGroupCollisionScene; };
 }
 /**
  * 
@@ -3289,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
      */
@@ -3825,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.
@@ -4106,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;
 }
 /**
  * 
@@ -8114,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);
@@ -8139,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;
 
@@ -8158,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),
@@ -8169,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);
@@ -8264,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;
 
@@ -8283,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),
@@ -8294,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));
     }
 }