@wandelbots/nova-api 25.6.0-dev.4 → 25.6.0-dev.6

package/v2/api.js

@@ -39,18 +39,14 @@ export const BlendingPositionBlendingNameEnum = {
 export const BooleanValueValueTypeEnum = {
     Boolean: 'boolean'
 };
-export const BoxTypeEnum = {
-    TypeHollow: 'TYPE_HOLLOW',
-    TypeFull: 'TYPE_FULL'
-};
-export const Box2ShapeTypeEnum = {
+export const BoxShapeTypeEnum = {
     Box: 'box'
 };
-export const Box2BoxTypeEnum = {
+export const BoxBoxTypeEnum = {
     Hollow: 'HOLLOW',
     Full: 'FULL'
 };
-export const Capsule2ShapeTypeEnum = {
+export const CapsuleShapeTypeEnum = {
     Capsule: 'capsule'
 };
 /**
@@ -66,10 +62,10 @@ export const Comparator = {
     ComparatorLess: 'COMPARATOR_LESS',
     ComparatorLessEqual: 'COMPARATOR_LESS_EQUAL'
 };
-export const ConvexHull2ShapeTypeEnum = {
+export const ConvexHullShapeTypeEnum = {
     ConvexHull: 'convex_hull'
 };
-export const Cylinder2ShapeTypeEnum = {
+export const CylinderShapeTypeEnum = {
     Cylinder: 'cylinder'
 };
 /**
@@ -136,26 +132,6 @@ export const InitializeMovementRequestMessageTypeEnum = {
 export const IntegerValueValueTypeEnum = {
     Integer: 'integer'
 };
-/**
- * Definition of the joint where the limits are applied.
- * @export
- * @enum {string}
- */
-export const JointName = {
-    JointnameAxisInvalid: 'JOINTNAME_AXIS_INVALID',
-    JointnameAxis1: 'JOINTNAME_AXIS_1',
-    JointnameAxis2: 'JOINTNAME_AXIS_2',
-    JointnameAxis3: 'JOINTNAME_AXIS_3',
-    JointnameAxis4: 'JOINTNAME_AXIS_4',
-    JointnameAxis5: 'JOINTNAME_AXIS_5',
-    JointnameAxis6: 'JOINTNAME_AXIS_6',
-    JointnameAxis7: 'JOINTNAME_AXIS_7',
-    JointnameAxis8: 'JOINTNAME_AXIS_8',
-    JointnameAxis9: 'JOINTNAME_AXIS_9',
-    JointnameAxis10: 'JOINTNAME_AXIS_10',
-    JointnameAxis11: 'JOINTNAME_AXIS_11',
-    JointnameAxis12: 'JOINTNAME_AXIS_12'
-};
 export const JointVelocityRequestMessageTypeEnum = {
     JointVelocityRequest: 'JointVelocityRequest'
 };
@@ -186,168 +162,6 @@ export const Manufacturer = {
     Universalrobots: 'universalrobots',
     Yaskawa: 'yaskawa'
 };
-/**
- * String identifiying the model of a motion group.
- * @export
- * @enum {string}
- */
-export const MotionGroupModel = {
-    Abb1200583: 'ABB_120_058_3',
-    Abb1400816: 'ABB_140_081_6',
-    Abb101003715: 'ABB_1010_037_15',
-    Abb11000584: 'ABB_1100_058_4',
-    Abb110004754: 'ABB_1100_0475_4',
-    Abb1200077: 'ABB_1200_07_7',
-    Abb130011510: 'ABB_1300_115_10',
-    Abb13000911: 'ABB_1300_09_11',
-    Abb13001412: 'ABB_1300_14_12',
-    Abb1300147: 'ABB_1300_14_7',
-    Abb14001445: 'ABB_1400_144_5',
-    Abb1520Id154: 'ABB_1520ID_15_4',
-    Abb1600126: 'ABB_1600_12_6',
-    Abb16001210: 'ABB_1600_12_10',
-    Abb16001456: 'ABB_1600_145_6',
-    Abb160014510: 'ABB_1600_145_10',
-    Abb1660Id1554: 'ABB_1660ID_155_4',
-    Abb260016512: 'ABB_2600_165_12',
-    Abb260016520: 'ABB_2600_165_20',
-    Abb260018512: 'ABB_2600_185_12',
-    Abb2600Id18515: 'ABB_2600ID_185_15',
-    Abb2600Id2008: 'ABB_2600ID_200_8',
-    Abb460025020: 'ABB_4600_250_20',
-    Abb460025540: 'ABB_4600_255_40',
-    Abb460020545: 'ABB_4600_205_45',
-    Abb460020560: 'ABB_4600_205_60',
-    FanucCr4iA: 'FANUC_CR4iA',
-    FanucCr7iA: 'FANUC_CR7iA',
-    FanucCr7iAl: 'FANUC_CR7iAL',
-    FanucCr14iAl: 'FANUC_CR14iAL',
-    FanucCr15iA: 'FANUC_CR15iA',
-    FanucCr35iA: 'FANUC_CR35iA',
-    FanucCr35iB: 'FANUC_CR35iB',
-    FanucCrx5iA: 'FANUC_CRX5iA',
-    FanucCrx10iA: 'FANUC_CRX10iA',
-    FanucCrx10iAl: 'FANUC_CRX10iAL',
-    FanucCrx20iAl: 'FANUC_CRX20iAL',
-    FanucCrx25iA: 'FANUC_CRX25iA',
-    FanucM10iD8L: 'FANUC_M10iD8L',
-    FanucM10iD10L: 'FANUC_M10iD10L',
-    FanucM10iD12: 'FANUC_M10iD12',
-    FanucM10iD16S: 'FANUC_M10iD16S',
-    FanucM20iB25: 'FANUC_M20iB25',
-    FanucM20iB25C: 'FANUC_M20iB25C',
-    FanucM20iB35S: 'FANUC_M20iB35S',
-    FanucM20iD12L: 'FANUC_M20iD12L',
-    FanucM20iD25: 'FANUC_M20iD25',
-    FanucM20iD35: 'FANUC_M20iD35',
-    FanucM900iB280L: 'FANUC_M900iB280L',
-    FanucM900iB360E: 'FANUC_M900iB360E',
-    FanucArcMate50iD: 'FANUC_ARC_Mate_50iD',
-    FanucArcMate50iD7L: 'FANUC_ARC_Mate_50iD7L',
-    FanucArcMate100iD: 'FANUC_ARC_Mate_100iD',
-    FanucArcMate100iD16S: 'FANUC_ARC_Mate_100iD16S',
-    FanucArcMate100iD8L: 'FANUC_ARC_Mate_100iD8L',
-    FanucArcMate100iD10L: 'FANUC_ARC_Mate_100iD10L',
-    FanucArcMate120iD: 'FANUC_ARC_Mate_120iD',
-    FanucArcMate120iD12L: 'FANUC_ARC_Mate_120iD12L',
-    FanucLrMate200iD: 'FANUC_LR_Mate_200iD',
-    FanucLrMate200iD4S: 'FANUC_LR_Mate_200iD4S',
-    FanucLrMate200iD7L: 'FANUC_LR_Mate_200iD7L',
-    FanucR2000iC125L: 'FANUC_R2000iC125L',
-    FanucR2000iC210F: 'FANUC_R2000iC210F',
-    UniversalRobotsUr3: 'UniversalRobots_UR3',
-    UniversalRobotsUr5: 'UniversalRobots_UR5',
-    UniversalRobotsUr10: 'UniversalRobots_UR10',
-    UniversalRobotsUr3e: 'UniversalRobots_UR3e',
-    UniversalRobotsUr5e: 'UniversalRobots_UR5e',
-    UniversalRobotsUr10e: 'UniversalRobots_UR10e',
-    UniversalRobotsUr16e: 'UniversalRobots_UR16e',
-    UniversalRobotsUr20e: 'UniversalRobots_UR20e',
-    YaskawaAr700: 'Yaskawa_AR700',
-    YaskawaAr900: 'Yaskawa_AR900',
-    YaskawaAr1440: 'Yaskawa_AR1440',
-    YaskawaAr1440E: 'Yaskawa_AR1440E',
-    YaskawaAr1730: 'Yaskawa_AR1730',
-    YaskawaAr2010: 'Yaskawa_AR2010',
-    YaskawaAr3120: 'Yaskawa_AR3120',
-    YaskawaGp4: 'Yaskawa_GP4',
-    YaskawaGp7: 'Yaskawa_GP7',
-    YaskawaGp8: 'Yaskawa_GP8',
-    YaskawaGp8L: 'Yaskawa_GP8L',
-    YaskawaGp12: 'Yaskawa_GP12',
-    YaskawaGp20Hl: 'Yaskawa_GP20HL',
-    YaskawaGp25: 'Yaskawa_GP25',
-    YaskawaGp25Sv: 'Yaskawa_GP25SV',
-    YaskawaGp2512: 'Yaskawa_GP25_12',
-    YaskawaGp35L: 'Yaskawa_GP35L',
-    YaskawaGp50: 'Yaskawa_GP50',
-    YaskawaGp70L: 'Yaskawa_GP70L',
-    YaskawaGp88: 'Yaskawa_GP88',
-    YaskawaGp110: 'Yaskawa_GP110',
-    YaskawaGp110B: 'Yaskawa_GP110B',
-    YaskawaGp110H: 'Yaskawa_GP110H',
-    YaskawaGp165R: 'Yaskawa_GP165R',
-    YaskawaGp180: 'Yaskawa_GP180',
-    YaskawaGp180H: 'Yaskawa_GP180H',
-    YaskawaGp180120: 'Yaskawa_GP180_120',
-    YaskawaGp200R: 'Yaskawa_GP200R',
-    YaskawaGp200S: 'Yaskawa_GP200S',
-    YaskawaGp215: 'Yaskawa_GP215',
-    YaskawaGp225: 'Yaskawa_GP225',
-    YaskawaGp225H: 'Yaskawa_GP225H',
-    YaskawaGp250: 'Yaskawa_GP250',
-    YaskawaGp280: 'Yaskawa_GP280',
-    YaskawaGp280L: 'Yaskawa_GP280L',
-    YaskawaGp300R: 'Yaskawa_GP300R',
-    YaskawaGp400: 'Yaskawa_GP400',
-    YaskawaGp400R: 'Yaskawa_GP400R',
-    YaskawaGp600: 'Yaskawa_GP600',
-    YaskawaHc10: 'Yaskawa_HC10',
-    YaskawaHc10Dtp: 'Yaskawa_HC10DTP',
-    YaskawaHc20Dtp: 'Yaskawa_HC20DTP',
-    YaskawaHc30Pl: 'Yaskawa_HC30PL',
-    YaskawaTurn1: 'Yaskawa_TURN1',
-    YaskawaTurn2: 'Yaskawa_TURN2',
-    YaskawaTurn3: 'Yaskawa_TURN3',
-    KukaKr150R2: 'KUKA_KR150_R2',
-    KukaKr3R540: 'KUKA_KR3_R540',
-    KukaKr4R600: 'KUKA_KR4_R600',
-    KukaKr6R700: 'KUKA_KR6_R700',
-    KukaKr6R7002: 'KUKA_KR6_R700_2',
-    KukaKr6R900: 'KUKA_KR6_R900',
-    KukaKr6R9002: 'KUKA_KR6_R900_2',
-    KukaKr6R1820: 'KUKA_KR6_R1820',
-    KukaKr10R900: 'KUKA_KR10_R900',
-    KukaKr10R9002: 'KUKA_KR10_R900_2',
-    KukaKr10R1100: 'KUKA_KR10_R1100',
-    KukaKr10R11002: 'KUKA_KR10_R1100_2',
-    KukaKr12R18102: 'KUKA_KR12_R1810_2',
-    KukaKr16R1610: 'KUKA_KR16_R1610',
-    KukaKr16R16102: 'KUKA_KR16_R1610_2',
-    KukaKr16R2010: 'KUKA_KR16_R2010',
-    KukaKr16R20102: 'KUKA_KR16_R2010_2',
-    KukaKr20R1810: 'KUKA_KR20_R1810',
-    KukaKr20R18102: 'KUKA_KR20_R1810_2',
-    KukaKr30R3: 'KUKA_KR30_R3',
-    KukaKr50R2500: 'KUKA_KR50_R2500',
-    KukaKr120R2700: 'KUKA_KR120_R2700',
-    KukaKr120R27002: 'KUKA_KR120_R2700_2',
-    KukaKr120R31002: 'KUKA_KR120_R3100_2',
-    KukaKr210R2700: 'KUKA_KR210_R2700',
-    KukaKr210R27002: 'KUKA_KR210_R2700_2',
-    KukaKr210R3100: 'KUKA_KR210_R3100',
-    KukaKr210R31002: 'KUKA_KR210_R3100_2',
-    KukaKr210R3300: 'KUKA_KR210_R3300',
-    KukaKr210R33002: 'KUKA_KR210_R3300_2',
-    KukaKr240R2700: 'KUKA_KR240_R2700',
-    KukaKr250R27002: 'KUKA_KR250_R2700_2',
-    KukaKr270R2700: 'KUKA_KR270_R2700',
-    KukaKr270R3100: 'KUKA_KR270_R3100',
-    KukaKr270R31002: 'KUKA_KR270_R3100_2',
-    KukaKr360R2830: 'KUKA_KR360_R2830',
-    KukaKr360L2403: 'KUKA_KR360_L240_3',
-    KukaLbrIisy11R1300: 'KUKA_LBR_IISY_11_R1300'
-};
 /**
  * The operating state.
  * @export
@@ -425,7 +239,7 @@ export const PathLinePathDefinitionNameEnum = {
 export const PauseMovementRequestMessageTypeEnum = {
     PauseMovementRequest: 'PauseMovementRequest'
 };
-export const Plane2ShapeTypeEnum = {
+export const PlaneShapeTypeEnum = {
     Plane: 'plane'
 };
 export const PlaybackSpeedRequestMessageTypeEnum = {
@@ -443,10 +257,10 @@ export const ProgramRunState = {
     Failed: 'failed',
     Stopped: 'stopped'
 };
-export const Rectangle2ShapeTypeEnum = {
+export const RectangleShapeTypeEnum = {
     Rectangle: 'rectangle'
 };
-export const RectangularCapsule2ShapeTypeEnum = {
+export const RectangularCapsuleShapeTypeEnum = {
     RectangularCapsule: 'rectangular_capsule'
 };
 /**
@@ -493,16 +307,6 @@ export const SafetyStateType = {
     SafetyStateRobotEmergencyStop: 'SAFETY_STATE_ROBOT_EMERGENCY_STOP',
     SafetyStateViolation: 'SAFETY_STATE_VIOLATION'
 };
-/**
- * The safety state that the settings are valid for.
- * @export
- * @enum {string}
- */
-export const SafetyType = {
-    SafetyInvalid: 'SAFETY_INVALID',
-    SafetyNormal: 'SAFETY_NORMAL',
-    SafetyReduced: 'SAFETY_REDUCED'
-};
 /**
  *
  * @export
@@ -564,7 +368,7 @@ export const SingularityTypeEnum = {
     Elbow: 'ELBOW',
     Shoulder: 'SHOULDER'
 };
-export const Sphere2ShapeTypeEnum = {
+export const SphereShapeTypeEnum = {
     Sphere: 'sphere'
 };
 /**
@@ -1932,21 +1736,26 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Get the current state of a robot controller.
-         * @summary State of Device
+         * Request a coordinate system specification for a given identifier. 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 Coordinate System
          * @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 {string} coordinateSystem Unique identifier addressing a coordinate system.
+         * @param {OrientationType} [orientationType]
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getCurrentRobotControllerState: async (cell, controller, options = {}) => {
+        getCoordinateSystem: async (cell, controller, coordinateSystem, orientationType, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getCurrentRobotControllerState', 'cell', cell);
+            assertParamExists('getCoordinateSystem', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getCurrentRobotControllerState', 'controller', controller);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/state`
+            assertParamExists('getCoordinateSystem', 'controller', controller);
+            // verify required parameter 'coordinateSystem' is not null or undefined
+            assertParamExists('getCoordinateSystem', 'coordinateSystem', coordinateSystem);
+            const localVarPath = `/cells/{cell}/controllers/{controller}/coordinate-systems/{coordinate-system}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
+                .replace(`{${"controller"}}`, encodeURIComponent(String(controller)))
+                .replace(`{${"coordinate-system"}}`, encodeURIComponent(String(coordinateSystem)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -1962,6 +1771,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 };
@@ -1971,19 +1783,19 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState).
-         * @summary Current Mode
+         * Get the current state of a robot controller.
+         * @summary State
          * @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 {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getMode: async (cell, controller, options = {}) => {
+        getCurrentRobotControllerState: async (cell, controller, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getMode', 'cell', cell);
+            assertParamExists('getCurrentRobotControllerState', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getMode', 'controller', controller);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/mode`
+            assertParamExists('getCurrentRobotControllerState', 'controller', controller);
+            const localVarPath = `/cells/{cell}/controllers/{controller}/state`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -2010,19 +1822,19 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Get the configuration for a robot controller.
-         * @summary Robot Controller Configuration
+         * Get the current robot system mode of a registered robot controller. The robot system mode indicates if a robot controller can be used. See [setDefaultMode](setDefaultMode) for more information about the different modes. The mode is influenced by the operating mode of the robot controller. The operating mode can be changed via [setDefaultMode](setDefaultMode). Request the current operating mode of the robot controller via [getCurrentRobotControllerState](getCurrentRobotControllerState).
+         * @summary Current Mode
          * @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 {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getRobotController: async (cell, controller, options = {}) => {
+        getMode: async (cell, controller, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getRobotController', 'cell', cell);
+            assertParamExists('getMode', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getRobotController', 'controller', controller);
-            const localVarPath = `/cells/{cell}/controllers/{controller}`
+            assertParamExists('getMode', 'controller', controller);
+            const localVarPath = `/cells/{cell}/controllers/{controller}/mode`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -2049,19 +1861,19 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Lists supported operating modes. Usually cobots support free drive and control, industrial robots only support control.
-         * @summary Supported Motion Modes
+         * Get the configuration for a robot controller.
+         * @summary Robot Controller
          * @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 {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getSupportedModes: async (cell, controller, options = {}) => {
+        getRobotController: async (cell, controller, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getSupportedModes', 'cell', cell);
+            assertParamExists('getRobotController', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('getSupportedModes', 'controller', controller);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/controller-capabilities`
+            assertParamExists('getRobotController', 'controller', controller);
+            const localVarPath = `/cells/{cell}/controllers/{controller}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -2128,7 +1940,7 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
         },
         /**
          * List all configured robot controllers.
-         * @summary List
+         * @summary List Descriptions
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -2162,22 +1974,20 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * 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
+         * 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 {SettableRobotSystemMode} mode
+         * @param {OrientationType} [orientationType]
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        setDefaultMode: async (cell, controller, mode, options = {}) => {
+        listCoordinateSystems: async (cell, controller, orientationType, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('setDefaultMode', 'cell', cell);
+            assertParamExists('listCoordinateSystems', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('setDefaultMode', 'controller', controller);
-            // verify required parameter 'mode' is not null or undefined
-            assertParamExists('setDefaultMode', 'mode', mode);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/mode`
+            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.
@@ -2186,7 +1996,7 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -2195,8 +2005,8 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (mode !== undefined) {
-                localVarQueryParameter['mode'] = mode;
+            if (orientationType !== undefined) {
+                localVarQueryParameter['orientation_type'] = orientationType;
             }
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
@@ -2207,20 +2017,22 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Sets the robot controller into freedrive mode and stays in freedrive until the websocket connection is closed by the client. In freedrive mode, it is possible to move the attached motion groups by hand. This is a blocking call. As long as the websocket connection is open, no other endpoint can control or move the robot.  <!-- theme: danger -->  > **DANGER**  > Danger caused by robot. Improper assessment by the integrator of the application-specific hazards can result in people being > crushed, drawn in or caught due to the robot\'s complex movement sequences. Before opening the websocket, ensure that  > - The robot is in a safe state,  > - The right payload is set (e.g by using the (getActivePayload)[getActivePayload] endpoint),  > - No humans or object are within the robot\'s reach or within the cell.  As long as the websocket connection is open you will get the current state of the robot system in the response in the specified response_rate. If the activation failed, the returned status will return possible reasons for the failure.  Free drive mode is only available for robot controllers that support it, in particular Collobarative Robots (\"Cobots\"). Use the (getSupportedModes)[getSupportedModes] endpoint to check if the robot controller supports free drive mode.
-         * @summary Stream Free Drive Mode
+         * 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
          * @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 {number} [responseRate]
+         * @param {SettableRobotSystemMode} mode
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        streamFreeDrive: async (cell, controller, responseRate, options = {}) => {
+        setDefaultMode: async (cell, controller, mode, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('streamFreeDrive', 'cell', cell);
+            assertParamExists('setDefaultMode', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('streamFreeDrive', 'controller', controller);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/free-drive-stream`
+            assertParamExists('setDefaultMode', 'controller', controller);
+            // verify required parameter 'mode' is not null or undefined
+            assertParamExists('setDefaultMode', 'mode', mode);
+            const localVarPath = `/cells/{cell}/controllers/{controller}/mode`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -2229,7 +2041,7 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -2238,8 +2050,8 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (responseRate !== undefined) {
-                localVarQueryParameter['response_rate'] = responseRate;
+            if (mode !== undefined) {
+                localVarQueryParameter['mode'] = mode;
             }
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
@@ -2250,19 +2062,20 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Receive updates of the current robot system mode of a robot controller via websocket upon robot system mode change. See [setDefaultMode](setDefaultMode) for more information about the different modes.
-         * @summary Stream Mode Change
+         * <!-- theme: danger -->  > Websocket endpoint  Sets the robot controller into freedrive mode and stays in freedrive until the websocket connection is closed by the client. In freedrive mode, it is possible to move the attached motion groups by hand. This is a blocking call. As long as the websocket connection is open, no other endpoint can control or move the robot.  <!-- theme: danger -->  > **DANGER**  > Danger caused by robot. Improper assessment by the integrator of the application-specific hazards can result in people being > crushed, drawn in or caught due to the robot\'s complex movement sequences. Before opening the websocket, ensure that  > - The robot is in a safe state,  > - The right payload is set (e.g by using the (getActivePayload)[getActivePayload] endpoint),  > - No humans or object are within the robot\'s reach or within the cell.  As long as the websocket connection is open you will get the current state of the robot system in the response in the specified response_rate. If the activation failed, the returned status will return possible reasons for the failure.  Free drive mode is only available for robot controllers that support it, in particular Collobarative Robots (\"Cobots\"). Use the (listController)[listController] endpoint to check if the robot controller supports free drive mode.
+         * @summary Stream Free Drive
          * @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 {number} [responseRate]
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        streamModeChange: async (cell, controller, options = {}) => {
+        streamFreeDrive: async (cell, controller, responseRate, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('streamModeChange', 'cell', cell);
+            assertParamExists('streamFreeDrive', 'cell', cell);
             // verify required parameter 'controller' is not null or undefined
-            assertParamExists('streamModeChange', 'controller', controller);
-            const localVarPath = `/cells/{cell}/controllers/{controller}/mode-stream`
+            assertParamExists('streamFreeDrive', 'controller', controller);
+            const localVarPath = `/cells/{cell}/controllers/{controller}/free-drive-stream`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"controller"}}`, encodeURIComponent(String(controller)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -2280,6 +2093,9 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            if (responseRate !== undefined) {
+                localVarQueryParameter['response_rate'] = responseRate;
+            }
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -2289,8 +2105,8 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Receive updates of the state of a robot controller.
-         * @summary Stream State of Device
+         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.
+         * @summary Stream State
          * @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 {number} [responseRate]
@@ -2333,7 +2149,7 @@ export const ControllerApiAxiosParamCreator = function (configuration) {
         },
         /**
          * Update the configuration of a robot controller.  Reconfigure certain options of a robot controller, or deploy a specific container image of a robot controller.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
-         * @summary Update Robot Controller Configuration
+         * @summary Update Robot Controller
          * @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 {RobotController} robotController
@@ -2432,9 +2248,25 @@ export const ControllerApiFp = function (configuration) {
             const localVarOperationServerBasePath = operationServerMap['ControllerApi.deleteRobotController']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
+        /**
+         * Request a coordinate system specification for a given identifier. 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 Coordinate System
+         * @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 {string} coordinateSystem Unique identifier addressing a coordinate system.
+         * @param {OrientationType} [orientationType]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getCoordinateSystem(cell, controller, coordinateSystem, orientationType, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getCoordinateSystem(cell, controller, coordinateSystem, orientationType, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['ControllerApi.getCoordinateSystem']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * Get the current state of a robot controller.
-         * @summary State of Device
+         * @summary State
          * @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 {*} [options] Override http request option.
@@ -2462,7 +2294,7 @@ export const ControllerApiFp = function (configuration) {
         },
         /**
          * Get the configuration for a robot controller.
-         * @summary Robot Controller Configuration
+         * @summary Robot Controller
          * @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 {*} [options] Override http request option.
@@ -2474,20 +2306,6 @@ export const ControllerApiFp = function (configuration) {
             const localVarOperationServerBasePath = operationServerMap['ControllerApi.getRobotController']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
-        /**
-         * Lists supported operating modes. Usually cobots support free drive and control, industrial robots only support control.
-         * @summary Supported Motion Modes
-         * @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 {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getSupportedModes(cell, controller, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getSupportedModes(cell, controller, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ControllerApi.getSupportedModes']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
         /**
          * Receive the configuration for a virtual robot controller. Used to configure a virtual robot controller via [addRobotController](addRobotController).  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle, and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
          * @summary Virtual Robot Configuration
@@ -2504,7 +2322,7 @@ export const ControllerApiFp = function (configuration) {
         },
         /**
          * List all configured robot controllers.
-         * @summary List
+         * @summary List Descriptions
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -2515,6 +2333,21 @@ export const ControllerApiFp = function (configuration) {
             const localVarOperationServerBasePath = operationServerMap['ControllerApi.listControllers']?.[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
+         * @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);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['ControllerApi.listCoordinateSystems']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || 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
@@ -2531,8 +2364,8 @@ export const ControllerApiFp = function (configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Sets the robot controller into freedrive mode and stays in freedrive until the websocket connection is closed by the client. In freedrive mode, it is possible to move the attached motion groups by hand. This is a blocking call. As long as the websocket connection is open, no other endpoint can control or move the robot.  <!-- theme: danger -->  > **DANGER**  > Danger caused by robot. Improper assessment by the integrator of the application-specific hazards can result in people being > crushed, drawn in or caught due to the robot\'s complex movement sequences. Before opening the websocket, ensure that  > - The robot is in a safe state,  > - The right payload is set (e.g by using the (getActivePayload)[getActivePayload] endpoint),  > - No humans or object are within the robot\'s reach or within the cell.  As long as the websocket connection is open you will get the current state of the robot system in the response in the specified response_rate. If the activation failed, the returned status will return possible reasons for the failure.  Free drive mode is only available for robot controllers that support it, in particular Collobarative Robots (\"Cobots\"). Use the (getSupportedModes)[getSupportedModes] endpoint to check if the robot controller supports free drive mode.
-         * @summary Stream Free Drive Mode
+         * <!-- theme: danger -->  > Websocket endpoint  Sets the robot controller into freedrive mode and stays in freedrive until the websocket connection is closed by the client. In freedrive mode, it is possible to move the attached motion groups by hand. This is a blocking call. As long as the websocket connection is open, no other endpoint can control or move the robot.  <!-- theme: danger -->  > **DANGER**  > Danger caused by robot. Improper assessment by the integrator of the application-specific hazards can result in people being > crushed, drawn in or caught due to the robot\'s complex movement sequences. Before opening the websocket, ensure that  > - The robot is in a safe state,  > - The right payload is set (e.g by using the (getActivePayload)[getActivePayload] endpoint),  > - No humans or object are within the robot\'s reach or within the cell.  As long as the websocket connection is open you will get the current state of the robot system in the response in the specified response_rate. If the activation failed, the returned status will return possible reasons for the failure.  Free drive mode is only available for robot controllers that support it, in particular Collobarative Robots (\"Cobots\"). Use the (listController)[listController] endpoint to check if the robot controller supports free drive mode.
+         * @summary Stream Free Drive
          * @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 {number} [responseRate]
@@ -2546,22 +2379,8 @@ export const ControllerApiFp = function (configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Receive updates of the current robot system mode of a robot controller via websocket upon robot system mode change. See [setDefaultMode](setDefaultMode) for more information about the different modes.
-         * @summary Stream Mode Change
-         * @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 {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async streamModeChange(cell, controller, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.streamModeChange(cell, controller, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ControllerApi.streamModeChange']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Receive updates of the state of a robot controller.
-         * @summary Stream State of Device
+         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.
+         * @summary Stream State
          * @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 {number} [responseRate]
@@ -2576,7 +2395,7 @@ export const ControllerApiFp = function (configuration) {
         },
         /**
          * Update the configuration of a robot controller.  Reconfigure certain options of a robot controller, or deploy a specific container image of a robot controller.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
-         * @summary Update Robot Controller Configuration
+         * @summary Update Robot Controller
          * @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 {RobotController} robotController
@@ -2634,9 +2453,22 @@ export const ControllerApiFactory = function (configuration, basePath, axios) {
         deleteRobotController(cell, controller, completionTimeout, options) {
             return localVarFp.deleteRobotController(cell, controller, completionTimeout, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Request a coordinate system specification for a given identifier. 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 Coordinate System
+         * @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 {string} coordinateSystem Unique identifier addressing a coordinate system.
+         * @param {OrientationType} [orientationType]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getCoordinateSystem(cell, controller, coordinateSystem, orientationType, options) {
+            return localVarFp.getCoordinateSystem(cell, controller, coordinateSystem, orientationType, options).then((request) => request(axios, basePath));
+        },
         /**
          * Get the current state of a robot controller.
-         * @summary State of Device
+         * @summary State
          * @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 {*} [options] Override http request option.
@@ -2658,7 +2490,7 @@ export const ControllerApiFactory = function (configuration, basePath, axios) {
         },
         /**
          * Get the configuration for a robot controller.
-         * @summary Robot Controller Configuration
+         * @summary Robot Controller
          * @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 {*} [options] Override http request option.
@@ -2667,17 +2499,6 @@ export const ControllerApiFactory = function (configuration, basePath, axios) {
         getRobotController(cell, controller, options) {
             return localVarFp.getRobotController(cell, controller, options).then((request) => request(axios, basePath));
         },
-        /**
-         * Lists supported operating modes. Usually cobots support free drive and control, industrial robots only support control.
-         * @summary Supported Motion Modes
-         * @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 {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getSupportedModes(cell, controller, options) {
-            return localVarFp.getSupportedModes(cell, controller, options).then((request) => request(axios, basePath));
-        },
         /**
          * Receive the configuration for a virtual robot controller. Used to configure a virtual robot controller via [addRobotController](addRobotController).  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle, and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
          * @summary Virtual Robot Configuration
@@ -2691,7 +2512,7 @@ export const ControllerApiFactory = function (configuration, basePath, axios) {
         },
         /**
          * List all configured robot controllers.
-         * @summary List
+         * @summary List Descriptions
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -2699,6 +2520,18 @@ export const ControllerApiFactory = function (configuration, basePath, axios) {
         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
+         * @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(cell, controller, orientationType, options) {
+            return localVarFp.listCoordinateSystems(cell, controller, orientationType, 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
@@ -2712,8 +2545,8 @@ export const ControllerApiFactory = function (configuration, basePath, axios) {
             return localVarFp.setDefaultMode(cell, controller, mode, options).then((request) => request(axios, basePath));
         },
         /**
-         * Sets the robot controller into freedrive mode and stays in freedrive until the websocket connection is closed by the client. In freedrive mode, it is possible to move the attached motion groups by hand. This is a blocking call. As long as the websocket connection is open, no other endpoint can control or move the robot.  <!-- theme: danger -->  > **DANGER**  > Danger caused by robot. Improper assessment by the integrator of the application-specific hazards can result in people being > crushed, drawn in or caught due to the robot\'s complex movement sequences. Before opening the websocket, ensure that  > - The robot is in a safe state,  > - The right payload is set (e.g by using the (getActivePayload)[getActivePayload] endpoint),  > - No humans or object are within the robot\'s reach or within the cell.  As long as the websocket connection is open you will get the current state of the robot system in the response in the specified response_rate. If the activation failed, the returned status will return possible reasons for the failure.  Free drive mode is only available for robot controllers that support it, in particular Collobarative Robots (\"Cobots\"). Use the (getSupportedModes)[getSupportedModes] endpoint to check if the robot controller supports free drive mode.
-         * @summary Stream Free Drive Mode
+         * <!-- theme: danger -->  > Websocket endpoint  Sets the robot controller into freedrive mode and stays in freedrive until the websocket connection is closed by the client. In freedrive mode, it is possible to move the attached motion groups by hand. This is a blocking call. As long as the websocket connection is open, no other endpoint can control or move the robot.  <!-- theme: danger -->  > **DANGER**  > Danger caused by robot. Improper assessment by the integrator of the application-specific hazards can result in people being > crushed, drawn in or caught due to the robot\'s complex movement sequences. Before opening the websocket, ensure that  > - The robot is in a safe state,  > - The right payload is set (e.g by using the (getActivePayload)[getActivePayload] endpoint),  > - No humans or object are within the robot\'s reach or within the cell.  As long as the websocket connection is open you will get the current state of the robot system in the response in the specified response_rate. If the activation failed, the returned status will return possible reasons for the failure.  Free drive mode is only available for robot controllers that support it, in particular Collobarative Robots (\"Cobots\"). Use the (listController)[listController] endpoint to check if the robot controller supports free drive mode.
+         * @summary Stream Free Drive
          * @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 {number} [responseRate]
@@ -2724,19 +2557,8 @@ export const ControllerApiFactory = function (configuration, basePath, axios) {
             return localVarFp.streamFreeDrive(cell, controller, responseRate, options).then((request) => request(axios, basePath));
         },
         /**
-         * Receive updates of the current robot system mode of a robot controller via websocket upon robot system mode change. See [setDefaultMode](setDefaultMode) for more information about the different modes.
-         * @summary Stream Mode Change
-         * @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 {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        streamModeChange(cell, controller, options) {
-            return localVarFp.streamModeChange(cell, controller, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Receive updates of the state of a robot controller.
-         * @summary Stream State of Device
+         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.
+         * @summary Stream State
          * @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 {number} [responseRate]
@@ -2748,7 +2570,7 @@ export const ControllerApiFactory = function (configuration, basePath, axios) {
         },
         /**
          * Update the configuration of a robot controller.  Reconfigure certain options of a robot controller, or deploy a specific container image of a robot controller.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
-         * @summary Update Robot Controller Configuration
+         * @summary Update Robot Controller
          * @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 {RobotController} robotController
@@ -2806,9 +2628,23 @@ export class ControllerApi extends BaseAPI {
     deleteRobotController(cell, controller, completionTimeout, options) {
         return ControllerApiFp(this.configuration).deleteRobotController(cell, controller, completionTimeout, options).then((request) => request(this.axios, this.basePath));
     }
+    /**
+     * Request a coordinate system specification for a given identifier. 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 Coordinate System
+     * @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 {string} coordinateSystem Unique identifier addressing a coordinate system.
+     * @param {OrientationType} [orientationType]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ControllerApi
+     */
+    getCoordinateSystem(cell, controller, coordinateSystem, orientationType, options) {
+        return ControllerApiFp(this.configuration).getCoordinateSystem(cell, controller, coordinateSystem, orientationType, options).then((request) => request(this.axios, this.basePath));
+    }
     /**
      * Get the current state of a robot controller.
-     * @summary State of Device
+     * @summary State
      * @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 {*} [options] Override http request option.
@@ -2832,7 +2668,7 @@ export class ControllerApi extends BaseAPI {
     }
     /**
      * Get the configuration for a robot controller.
-     * @summary Robot Controller Configuration
+     * @summary Robot Controller
      * @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 {*} [options] Override http request option.
@@ -2842,18 +2678,6 @@ export class ControllerApi extends BaseAPI {
     getRobotController(cell, controller, options) {
         return ControllerApiFp(this.configuration).getRobotController(cell, controller, options).then((request) => request(this.axios, this.basePath));
     }
-    /**
-     * Lists supported operating modes. Usually cobots support free drive and control, industrial robots only support control.
-     * @summary Supported Motion Modes
-     * @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 {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof ControllerApi
-     */
-    getSupportedModes(cell, controller, options) {
-        return ControllerApiFp(this.configuration).getSupportedModes(cell, controller, options).then((request) => request(this.axios, this.basePath));
-    }
     /**
      * Receive the configuration for a virtual robot controller. Used to configure a virtual robot controller via [addRobotController](addRobotController).  > **NOTE** > > The output generated by this endpoint can be too large for the site to handle, and may produce an error or incorrect output. > Use `curl` in combination with `> output.json` to capture the output, or use an API client like Postman.
      * @summary Virtual Robot Configuration
@@ -2868,7 +2692,7 @@ export class ControllerApi extends BaseAPI {
     }
     /**
      * List all configured robot controllers.
-     * @summary List
+     * @summary List Descriptions
      * @param {string} cell Unique identifier addressing a cell in all API calls.
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
@@ -2878,46 +2702,47 @@ export class ControllerApi extends BaseAPI {
         return ControllerApiFp(this.configuration).listControllers(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.
-     * @summary Set Default Mode
+     * 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 {SettableRobotSystemMode} mode
+     * @param {OrientationType} [orientationType]
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ControllerApi
      */
-    setDefaultMode(cell, controller, mode, options) {
-        return ControllerApiFp(this.configuration).setDefaultMode(cell, controller, mode, 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));
     }
     /**
-     * Sets the robot controller into freedrive mode and stays in freedrive until the websocket connection is closed by the client. In freedrive mode, it is possible to move the attached motion groups by hand. This is a blocking call. As long as the websocket connection is open, no other endpoint can control or move the robot.  <!-- theme: danger -->  > **DANGER**  > Danger caused by robot. Improper assessment by the integrator of the application-specific hazards can result in people being > crushed, drawn in or caught due to the robot\'s complex movement sequences. Before opening the websocket, ensure that  > - The robot is in a safe state,  > - The right payload is set (e.g by using the (getActivePayload)[getActivePayload] endpoint),  > - No humans or object are within the robot\'s reach or within the cell.  As long as the websocket connection is open you will get the current state of the robot system in the response in the specified response_rate. If the activation failed, the returned status will return possible reasons for the failure.  Free drive mode is only available for robot controllers that support it, in particular Collobarative Robots (\"Cobots\"). Use the (getSupportedModes)[getSupportedModes] endpoint to check if the robot controller supports free drive mode.
-     * @summary Stream Free Drive Mode
+     * 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
      * @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 {number} [responseRate]
+     * @param {SettableRobotSystemMode} mode
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ControllerApi
      */
-    streamFreeDrive(cell, controller, responseRate, options) {
-        return ControllerApiFp(this.configuration).streamFreeDrive(cell, controller, responseRate, options).then((request) => request(this.axios, this.basePath));
+    setDefaultMode(cell, controller, mode, options) {
+        return ControllerApiFp(this.configuration).setDefaultMode(cell, controller, mode, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Receive updates of the current robot system mode of a robot controller via websocket upon robot system mode change. See [setDefaultMode](setDefaultMode) for more information about the different modes.
-     * @summary Stream Mode Change
+     * <!-- theme: danger -->  > Websocket endpoint  Sets the robot controller into freedrive mode and stays in freedrive until the websocket connection is closed by the client. In freedrive mode, it is possible to move the attached motion groups by hand. This is a blocking call. As long as the websocket connection is open, no other endpoint can control or move the robot.  <!-- theme: danger -->  > **DANGER**  > Danger caused by robot. Improper assessment by the integrator of the application-specific hazards can result in people being > crushed, drawn in or caught due to the robot\'s complex movement sequences. Before opening the websocket, ensure that  > - The robot is in a safe state,  > - The right payload is set (e.g by using the (getActivePayload)[getActivePayload] endpoint),  > - No humans or object are within the robot\'s reach or within the cell.  As long as the websocket connection is open you will get the current state of the robot system in the response in the specified response_rate. If the activation failed, the returned status will return possible reasons for the failure.  Free drive mode is only available for robot controllers that support it, in particular Collobarative Robots (\"Cobots\"). Use the (listController)[listController] endpoint to check if the robot controller supports free drive mode.
+     * @summary Stream Free Drive
      * @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 {number} [responseRate]
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ControllerApi
      */
-    streamModeChange(cell, controller, options) {
-        return ControllerApiFp(this.configuration).streamModeChange(cell, controller, options).then((request) => request(this.axios, this.basePath));
+    streamFreeDrive(cell, controller, responseRate, options) {
+        return ControllerApiFp(this.configuration).streamFreeDrive(cell, controller, responseRate, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Receive updates of the state of a robot controller.
-     * @summary Stream State of Device
+     * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the state of a robot controller.
+     * @summary Stream State
      * @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 {number} [responseRate]
@@ -2930,7 +2755,7 @@ export class ControllerApi extends BaseAPI {
     }
     /**
      * Update the configuration of a robot controller.  Reconfigure certain options of a robot controller, or deploy a specific container image of a robot controller.  <!-- theme: warning --> > **WARNING** > > Using it in conjunction with the settings app may lead to unpredictable behavior.
-     * @summary Update Robot Controller Configuration
+     * @summary Update Robot Controller
      * @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 {RobotController} robotController
@@ -3092,7 +2917,7 @@ export const ControllerInputsOutputsApiAxiosParamCreator = function (configurati
             };
         },
         /**
-         * Continuously receive updates of input/output values via websocket. Updates are sent in the update rate of the controller.  > **NOTE** > > Do not request too many values simultaneously as the request is then likely to fail. The amount of values that can be streamed simultaneously depends on the specific robot controller.  > **NOTE** > > The inputs and outputs are sent in the update rate of the controller to prevent losing any values. Consider that this might lead to a high amount of data transmitted.
+         * <!-- theme: danger -->  > Websocket endpoint  Continuously receive updates of input/output values via websocket. Updates are sent in the update rate of the controller.  > **NOTE** > > Do not request too many values simultaneously as the request is then likely to fail. The amount of values that can be streamed simultaneously depends on the specific robot controller.  > **NOTE** > > The inputs and outputs are sent in the update rate of the controller to prevent losing any values. Consider that this might lead to a high amount of data transmitted.
          * @summary Stream Input/Output Values
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} controller Unique identifier to address a controller in the cell.
@@ -3236,7 +3061,7 @@ export const ControllerInputsOutputsApiFp = function (configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Continuously receive updates of input/output values via websocket. Updates are sent in the update rate of the controller.  > **NOTE** > > Do not request too many values simultaneously as the request is then likely to fail. The amount of values that can be streamed simultaneously depends on the specific robot controller.  > **NOTE** > > The inputs and outputs are sent in the update rate of the controller to prevent losing any values. Consider that this might lead to a high amount of data transmitted.
+         * <!-- theme: danger -->  > Websocket endpoint  Continuously receive updates of input/output values via websocket. Updates are sent in the update rate of the controller.  > **NOTE** > > Do not request too many values simultaneously as the request is then likely to fail. The amount of values that can be streamed simultaneously depends on the specific robot controller.  > **NOTE** > > The inputs and outputs are sent in the update rate of the controller to prevent losing any values. Consider that this might lead to a high amount of data transmitted.
          * @summary Stream Input/Output Values
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} controller Unique identifier to address a controller in the cell.
@@ -3314,7 +3139,7 @@ export const ControllerInputsOutputsApiFactory = function (configuration, basePa
             return localVarFp.setOutputValues(cell, controller, setOutputValuesRequestInner, options).then((request) => request(axios, basePath));
         },
         /**
-         * Continuously receive updates of input/output values via websocket. Updates are sent in the update rate of the controller.  > **NOTE** > > Do not request too many values simultaneously as the request is then likely to fail. The amount of values that can be streamed simultaneously depends on the specific robot controller.  > **NOTE** > > The inputs and outputs are sent in the update rate of the controller to prevent losing any values. Consider that this might lead to a high amount of data transmitted.
+         * <!-- theme: danger -->  > Websocket endpoint  Continuously receive updates of input/output values via websocket. Updates are sent in the update rate of the controller.  > **NOTE** > > Do not request too many values simultaneously as the request is then likely to fail. The amount of values that can be streamed simultaneously depends on the specific robot controller.  > **NOTE** > > The inputs and outputs are sent in the update rate of the controller to prevent losing any values. Consider that this might lead to a high amount of data transmitted.
          * @summary Stream Input/Output Values
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} controller Unique identifier to address a controller in the cell.
@@ -3389,7 +3214,7 @@ export class ControllerInputsOutputsApi extends BaseAPI {
         return ControllerInputsOutputsApiFp(this.configuration).setOutputValues(cell, controller, setOutputValuesRequestInner, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Continuously receive updates of input/output values via websocket. Updates are sent in the update rate of the controller.  > **NOTE** > > Do not request too many values simultaneously as the request is then likely to fail. The amount of values that can be streamed simultaneously depends on the specific robot controller.  > **NOTE** > > The inputs and outputs are sent in the update rate of the controller to prevent losing any values. Consider that this might lead to a high amount of data transmitted.
+     * <!-- theme: danger -->  > Websocket endpoint  Continuously receive updates of input/output values via websocket. Updates are sent in the update rate of the controller.  > **NOTE** > > Do not request too many values simultaneously as the request is then likely to fail. The amount of values that can be streamed simultaneously depends on the specific robot controller.  > **NOTE** > > The inputs and outputs are sent in the update rate of the controller to prevent losing any values. Consider that this might lead to a high amount of data transmitted.
      * @summary Stream Input/Output Values
      * @param {string} cell Unique identifier addressing a cell in all API calls.
      * @param {string} controller Unique identifier to address a controller in the cell.
@@ -3416,35 +3241,31 @@ export class ControllerInputsOutputsApi extends BaseAPI {
     }
 }
 /**
- * CoordinateSystemsApi - axios parameter creator
+ * InverseKinematicsApi - axios parameter creator
  * @export
  */
-export const CoordinateSystemsApiAxiosParamCreator = function (configuration) {
+export const InverseKinematicsApiAxiosParamCreator = function (configuration) {
     return {
         /**
-         * Request a coordinate system specification for a given identifier. 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 Description
+         * 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 {string} coordinateSystem Unique identifier addressing a coordinate system.
-         * @param {OrientationType} [orientationType]
+         * @param {InverseKinematicsRequest} [inverseKinematicsRequest]
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getCoordinateSystem: async (cell, coordinateSystem, orientationType, options = {}) => {
+        inverseKinematics: async (cell, inverseKinematicsRequest, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getCoordinateSystem', 'cell', cell);
-            // verify required parameter 'coordinateSystem' is not null or undefined
-            assertParamExists('getCoordinateSystem', 'coordinateSystem', coordinateSystem);
-            const localVarPath = `/cells/{cell}/coordinate-systems/{coordinate-system}`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"coordinate-system"}}`, encodeURIComponent(String(coordinateSystem)));
+            assertParamExists('inverseKinematics', 'cell', cell);
+            const localVarPath = `/cells/{cell}/kinematic/inverse-kinematics`
+                .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;
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -3453,284 +3274,11 @@ export const CoordinateSystemsApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (orientationType !== undefined) {
-                localVarQueryParameter['orientation_type'] = orientationType;
-            }
+            localVarHeaderParameter['Content-Type'] = 'application/json';
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * 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
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {OrientationType} [orientationType]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        listCoordinateSystems: async (cell, orientationType, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('listCoordinateSystems', 'cell', cell);
-            const localVarPath = `/cells/{cell}/coordinate-systems`
-                .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;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, 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 };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Transform a pose to another base.
-         * @summary Transform
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
-         * @param {PoseInCoordinateSystem} poseInCoordinateSystem
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        transformInCoordinateSystem: async (cell, coordinateSystem, poseInCoordinateSystem, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('transformInCoordinateSystem', 'cell', cell);
-            // verify required parameter 'coordinateSystem' is not null or undefined
-            assertParamExists('transformInCoordinateSystem', 'coordinateSystem', coordinateSystem);
-            // verify required parameter 'poseInCoordinateSystem' is not null or undefined
-            assertParamExists('transformInCoordinateSystem', 'poseInCoordinateSystem', poseInCoordinateSystem);
-            const localVarPath = `/cells/{cell}/coordinate-systems/{coordinate-system}/transform`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"coordinate-system"}}`, encodeURIComponent(String(coordinateSystem)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            localVarHeaderParameter['Content-Type'] = 'application/json';
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            localVarRequestOptions.data = serializeDataIfNeeded(poseInCoordinateSystem, localVarRequestOptions, configuration);
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-    };
-};
-/**
- * CoordinateSystemsApi - functional programming interface
- * @export
- */
-export const CoordinateSystemsApiFp = function (configuration) {
-    const localVarAxiosParamCreator = CoordinateSystemsApiAxiosParamCreator(configuration);
-    return {
-        /**
-         * Request a coordinate system specification for a given identifier. 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 Description
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
-         * @param {OrientationType} [orientationType]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getCoordinateSystem(cell, coordinateSystem, orientationType, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getCoordinateSystem(cell, coordinateSystem, orientationType, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['CoordinateSystemsApi.getCoordinateSystem']?.[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
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {OrientationType} [orientationType]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async listCoordinateSystems(cell, orientationType, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listCoordinateSystems(cell, orientationType, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['CoordinateSystemsApi.listCoordinateSystems']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Transform a pose to another base.
-         * @summary Transform
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
-         * @param {PoseInCoordinateSystem} poseInCoordinateSystem
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async transformInCoordinateSystem(cell, coordinateSystem, poseInCoordinateSystem, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.transformInCoordinateSystem(cell, coordinateSystem, poseInCoordinateSystem, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['CoordinateSystemsApi.transformInCoordinateSystem']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-    };
-};
-/**
- * CoordinateSystemsApi - factory interface
- * @export
- */
-export const CoordinateSystemsApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = CoordinateSystemsApiFp(configuration);
-    return {
-        /**
-         * Request a coordinate system specification for a given identifier. 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 Description
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
-         * @param {OrientationType} [orientationType]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getCoordinateSystem(cell, coordinateSystem, orientationType, options) {
-            return localVarFp.getCoordinateSystem(cell, coordinateSystem, orientationType, 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
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {OrientationType} [orientationType]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        listCoordinateSystems(cell, orientationType, options) {
-            return localVarFp.listCoordinateSystems(cell, orientationType, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Transform a pose to another base.
-         * @summary Transform
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
-         * @param {PoseInCoordinateSystem} poseInCoordinateSystem
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        transformInCoordinateSystem(cell, coordinateSystem, poseInCoordinateSystem, options) {
-            return localVarFp.transformInCoordinateSystem(cell, coordinateSystem, poseInCoordinateSystem, options).then((request) => request(axios, basePath));
-        },
-    };
-};
-/**
- * CoordinateSystemsApi - object-oriented interface
- * @export
- * @class CoordinateSystemsApi
- * @extends {BaseAPI}
- */
-export class CoordinateSystemsApi extends BaseAPI {
-    /**
-     * Request a coordinate system specification for a given identifier. 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 Description
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
-     * @param {OrientationType} [orientationType]
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof CoordinateSystemsApi
-     */
-    getCoordinateSystem(cell, coordinateSystem, orientationType, options) {
-        return CoordinateSystemsApiFp(this.configuration).getCoordinateSystem(cell, coordinateSystem, 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
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {OrientationType} [orientationType]
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof CoordinateSystemsApi
-     */
-    listCoordinateSystems(cell, orientationType, options) {
-        return CoordinateSystemsApiFp(this.configuration).listCoordinateSystems(cell, orientationType, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Transform a pose to another base.
-     * @summary Transform
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} coordinateSystem Unique identifier addressing a coordinate system.
-     * @param {PoseInCoordinateSystem} poseInCoordinateSystem
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof CoordinateSystemsApi
-     */
-    transformInCoordinateSystem(cell, coordinateSystem, poseInCoordinateSystem, options) {
-        return CoordinateSystemsApiFp(this.configuration).transformInCoordinateSystem(cell, coordinateSystem, poseInCoordinateSystem, options).then((request) => request(this.axios, this.basePath));
-    }
-}
-/**
- * InverseKinematicsApi - axios parameter creator
- * @export
- */
-export const InverseKinematicsApiAxiosParamCreator = function (configuration) {
-    return {
-        /**
-         * 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 {InverseKinematicsRequest} [inverseKinematicsRequest]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        inverseKinematics: async (cell, inverseKinematicsRequest, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('inverseKinematics', 'cell', cell);
-            const localVarPath = `/cells/{cell}/kinematic/inverse-kinematics`
-                .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;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            localVarHeaderParameter['Content-Type'] = 'application/json';
-            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(inverseKinematicsRequest, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
@@ -4209,27 +3757,29 @@ export class LicenseApi extends BaseAPI {
 export const MotionGroupApiAxiosParamCreator = function (configuration) {
     return {
         /**
-         * Activate the motion group and keeps the motion group in an active status. To activate all motion groups of a robot controller, use this endpoint. It will return all activated motion groups of that controller.  When activating motion groups, it is not possible to interact with the controller in any other way.  To deactivate a motion group, use [deactivateMotionGroup](deactivateMotionGroup).
-         * @summary Activate All
+         * Returns the current state of the selected motion group including the current joint position, velocity, pose, and more.
+         * @summary State
          * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} controller
+         * @param {string} motionGroup The motion-group identifier.
+         * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the responses should be converted. If not set, world coordinate system is used.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        activateAllMotionGroups: async (cell, controller, options = {}) => {
+        getCurrentMotionGroupState: async (cell, motionGroup, responseCoordinateSystem, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('activateAllMotionGroups', 'cell', cell);
-            // verify required parameter 'controller' is not null or undefined
-            assertParamExists('activateAllMotionGroups', 'controller', controller);
-            const localVarPath = `/cells/{cell}/motion-groups/all`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
+            assertParamExists('getCurrentMotionGroupState', 'cell', cell);
+            // verify required parameter 'motionGroup' is not null or undefined
+            assertParamExists('getCurrentMotionGroupState', 'motionGroup', motionGroup);
+            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/state`
+                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
+                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -4238,8 +3788,8 @@ export const MotionGroupApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (controller !== undefined) {
-                localVarQueryParameter['controller'] = controller;
+            if (responseCoordinateSystem !== undefined) {
+                localVarQueryParameter['response_coordinate_system'] = responseCoordinateSystem;
             }
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
@@ -4250,27 +3800,28 @@ export const MotionGroupApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Activate the motion group and keeps the motion group in an active status. To manually activate a motion group, use this endpoint.  When activating a motion group, interacting with the controller in other ways is not possible.  To deactivate a motion group, use [deactivateMotionGroup](deactivateMotionGroup).
-         * @summary Activate
+         * Get the complete set of parameters that can be passed to the motion-planner (incl. safety zones, limits etc.).
+         * @summary Planning Parameters
          * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup
+         * @param {string} motionGroup The motion-group identifier.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        activateMotionGroup: async (cell, motionGroup, options = {}) => {
+        getPlanningParameters: async (cell, motionGroup, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('activateMotionGroup', 'cell', cell);
+            assertParamExists('getPlanningParameters', 'cell', cell);
             // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('activateMotionGroup', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
+            assertParamExists('getPlanningParameters', 'motionGroup', motionGroup);
+            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/planning-parameters`
+                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
+                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -4279,9 +3830,6 @@ export const MotionGroupApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (motionGroup !== undefined) {
-                localVarQueryParameter['motion_group'] = motionGroup;
-            }
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -4291,19 +3839,21 @@ export const MotionGroupApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Deactivate a motion group. Activate the motion group and keeps the motion group in an active status.  The robot controller streams information about all active motion groups. Deactivate motion groups that you no longer use.  When deactivating motion groups, it is not possible to interact with the controller in any other way.
-         * @summary Deactivate
+         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected.
+         * @summary Stream State
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} motionGroup The motion-group identifier.
+         * @param {number} [responseRate] Update rate for the response message in milliseconds (ms). Default is 200 ms. We recommend to use the step rate of the controller or a multiple of the step rate as NOVA updates the state in the controller\&#39;s step rate as well. Minimal response rate is the step rate of controller.
+         * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default is the world coordinate system.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        deactivateMotionGroup: async (cell, motionGroup, options = {}) => {
+        streamMotionGroupState: async (cell, motionGroup, responseRate, responseCoordinateSystem, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('deactivateMotionGroup', 'cell', cell);
+            assertParamExists('streamMotionGroupState', 'cell', cell);
             // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('deactivateMotionGroup', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}`
+            assertParamExists('streamMotionGroupState', 'motionGroup', motionGroup);
+            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/state-stream`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -4312,7 +3862,7 @@ export const MotionGroupApiAxiosParamCreator = function (configuration) {
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'DELETE', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -4321,6 +3871,12 @@ export const MotionGroupApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            if (responseRate !== undefined) {
+                localVarQueryParameter['response_rate'] = responseRate;
+            }
+            if (responseCoordinateSystem !== undefined) {
+                localVarQueryParameter['response_coordinate_system'] = responseCoordinateSystem;
+            }
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -4329,1576 +3885,152 @@ export const MotionGroupApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         },
+    };
+};
+/**
+ * MotionGroupApi - functional programming interface
+ * @export
+ */
+export const MotionGroupApiFp = function (configuration) {
+    const localVarAxiosParamCreator = MotionGroupApiAxiosParamCreator(configuration);
+    return {
         /**
-         * List all active motion groups. A motion group is active if it is currently used by a controller.
-         * @summary List Active
+         * Returns the current state of the selected motion group including the current joint position, velocity, pose, and more.
+         * @summary State
          * @param {string} cell Unique identifier addressing a cell in all API calls.
+         * @param {string} motionGroup The motion-group identifier.
+         * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the responses should be converted. If not set, world coordinate system is used.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listMotionGroups: async (cell, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('listMotionGroups', 'cell', cell);
-            const localVarPath = `/cells/{cell}/motion-groups`
-                .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;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-    };
-};
-/**
- * MotionGroupApi - functional programming interface
- * @export
- */
-export const MotionGroupApiFp = function (configuration) {
-    const localVarAxiosParamCreator = MotionGroupApiAxiosParamCreator(configuration);
-    return {
-        /**
-         * Activate the motion group and keeps the motion group in an active status. To activate all motion groups of a robot controller, use this endpoint. It will return all activated motion groups of that controller.  When activating motion groups, it is not possible to interact with the controller in any other way.  To deactivate a motion group, use [deactivateMotionGroup](deactivateMotionGroup).
-         * @summary Activate All
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} controller
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async activateAllMotionGroups(cell, controller, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.activateAllMotionGroups(cell, controller, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupApi.activateAllMotionGroups']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Activate the motion group and keeps the motion group in an active status. To manually activate a motion group, use this endpoint.  When activating a motion group, interacting with the controller in other ways is not possible.  To deactivate a motion group, use [deactivateMotionGroup](deactivateMotionGroup).
-         * @summary Activate
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async activateMotionGroup(cell, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.activateMotionGroup(cell, motionGroup, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupApi.activateMotionGroup']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Deactivate a motion group. Activate the motion group and keeps the motion group in an active status.  The robot controller streams information about all active motion groups. Deactivate motion groups that you no longer use.  When deactivating motion groups, it is not possible to interact with the controller in any other way.
-         * @summary Deactivate
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async deactivateMotionGroup(cell, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.deactivateMotionGroup(cell, motionGroup, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupApi.deactivateMotionGroup']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * List all active motion groups. A motion group is active if it is currently used by a controller.
-         * @summary List Active
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async listMotionGroups(cell, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listMotionGroups(cell, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupApi.listMotionGroups']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-    };
-};
-/**
- * MotionGroupApi - factory interface
- * @export
- */
-export const MotionGroupApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = MotionGroupApiFp(configuration);
-    return {
-        /**
-         * Activate the motion group and keeps the motion group in an active status. To activate all motion groups of a robot controller, use this endpoint. It will return all activated motion groups of that controller.  When activating motion groups, it is not possible to interact with the controller in any other way.  To deactivate a motion group, use [deactivateMotionGroup](deactivateMotionGroup).
-         * @summary Activate All
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} controller
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        activateAllMotionGroups(cell, controller, options) {
-            return localVarFp.activateAllMotionGroups(cell, controller, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Activate the motion group and keeps the motion group in an active status. To manually activate a motion group, use this endpoint.  When activating a motion group, interacting with the controller in other ways is not possible.  To deactivate a motion group, use [deactivateMotionGroup](deactivateMotionGroup).
-         * @summary Activate
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        activateMotionGroup(cell, motionGroup, options) {
-            return localVarFp.activateMotionGroup(cell, motionGroup, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Deactivate a motion group. Activate the motion group and keeps the motion group in an active status.  The robot controller streams information about all active motion groups. Deactivate motion groups that you no longer use.  When deactivating motion groups, it is not possible to interact with the controller in any other way.
-         * @summary Deactivate
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        deactivateMotionGroup(cell, motionGroup, options) {
-            return localVarFp.deactivateMotionGroup(cell, motionGroup, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * List all active motion groups. A motion group is active if it is currently used by a controller.
-         * @summary List Active
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        listMotionGroups(cell, options) {
-            return localVarFp.listMotionGroups(cell, options).then((request) => request(axios, basePath));
-        },
-    };
-};
-/**
- * MotionGroupApi - object-oriented interface
- * @export
- * @class MotionGroupApi
- * @extends {BaseAPI}
- */
-export class MotionGroupApi extends BaseAPI {
-    /**
-     * Activate the motion group and keeps the motion group in an active status. To activate all motion groups of a robot controller, use this endpoint. It will return all activated motion groups of that controller.  When activating motion groups, it is not possible to interact with the controller in any other way.  To deactivate a motion group, use [deactivateMotionGroup](deactivateMotionGroup).
-     * @summary Activate All
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} controller
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupApi
-     */
-    activateAllMotionGroups(cell, controller, options) {
-        return MotionGroupApiFp(this.configuration).activateAllMotionGroups(cell, controller, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Activate the motion group and keeps the motion group in an active status. To manually activate a motion group, use this endpoint.  When activating a motion group, interacting with the controller in other ways is not possible.  To deactivate a motion group, use [deactivateMotionGroup](deactivateMotionGroup).
-     * @summary Activate
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} motionGroup
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupApi
-     */
-    activateMotionGroup(cell, motionGroup, options) {
-        return MotionGroupApiFp(this.configuration).activateMotionGroup(cell, motionGroup, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Deactivate a motion group. Activate the motion group and keeps the motion group in an active status.  The robot controller streams information about all active motion groups. Deactivate motion groups that you no longer use.  When deactivating motion groups, it is not possible to interact with the controller in any other way.
-     * @summary Deactivate
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} motionGroup The motion-group identifier.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupApi
-     */
-    deactivateMotionGroup(cell, motionGroup, options) {
-        return MotionGroupApiFp(this.configuration).deactivateMotionGroup(cell, motionGroup, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * List all active motion groups. A motion group is active if it is currently used by a controller.
-     * @summary List Active
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupApi
-     */
-    listMotionGroups(cell, options) {
-        return MotionGroupApiFp(this.configuration).listMotionGroups(cell, options).then((request) => request(this.axios, this.basePath));
-    }
-}
-/**
- * MotionGroupInfoApi - axios parameter creator
- * @export
- */
-export const MotionGroupInfoApiAxiosParamCreator = function (configuration) {
-    return {
-        /**
-         * Gets the currently selected payload of the motion group. The payload is defined as the sum of all weights attached to the flange/endpoint of the motion group, e.g. sum of the tools and workpiece weight that are currently attached.
-         * @summary Selected Payload
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getActivePayload: async (cell, motionGroup, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getActivePayload', 'cell', cell);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('getActivePayload', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/payloads/current`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Get the internal selected TCP of a connected device.  Use parameter orientation_type to get the orientation part of the transformation offset returned in the requested orientation notation. If parameter orientation_type is not set, the orientation part of the transformation offset is returned in rotation vector notation. If use_controller_orientation is set to true the orientation type used on the robot controller is used and the may specified orientation_type is ignored. This can be useful for visualization purposes in the client application due to equivalent numbers with robot control panel visualization.
-         * @summary Selected TCP
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {OrientationType} [orientationType]
-         * @param {boolean} [useControllerOrientation]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getActiveTcp: async (cell, motionGroup, orientationType, useControllerOrientation, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getActiveTcp', 'cell', cell);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('getActiveTcp', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/tcps/current`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (orientationType !== undefined) {
-                localVarQueryParameter['orientation_type'] = orientationType;
-            }
-            if (useControllerOrientation !== undefined) {
-                localVarQueryParameter['use_controller_orientation'] = useControllerOrientation;
-            }
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Returns the current state of the selected motion group including the current joint position, velocity, pose, and more.
-         * @summary State of Device
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the responses should be converted. If not set, world coordinate system is used.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getCurrentMotionGroupState: async (cell, motionGroup, responseCoordinateSystem, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getCurrentMotionGroupState', 'cell', cell);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('getCurrentMotionGroupState', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/state`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (responseCoordinateSystem !== undefined) {
-                localVarQueryParameter['response_coordinate_system'] = responseCoordinateSystem;
-            }
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Lists options the motion group offers in regard to the information service.  Some motion groups may not provide all information services, e.g. some manufacturers don\'t have a blending zone concept.
-         * @summary Capabilities
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getInfoCapabilities: async (cell, motionGroup, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getInfoCapabilities', 'cell', cell);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('getInfoCapabilities', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/info-capabilities`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Lists options the motion group offers in regard to jogging.  Some motion groups may not provide all information services, e.g. it is physically not possible to move a one-axis-turntable in a linear way.
-         * @summary Jogging Capabilities
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getJoggingCapabilities: async (cell, motionGroup, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getJoggingCapabilities', 'cell', cell);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('getJoggingCapabilities', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/capability/jogging`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Get static properties of the motion group. Those properties are used internally for motion group plannning. Only supported motion groups will return a valid response.
-         * @summary Get Static Properties
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getMotionGroupSpecification: async (cell, motionGroup, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getMotionGroupSpecification', 'cell', cell);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('getMotionGroupSpecification', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/specification`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Returns the configured mounting pose offset in relation to world coordinate system and the motion group\'s coordinate system.
-         * @summary Device Mounting
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getMounting: async (cell, motionGroup, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getMounting', 'cell', cell);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('getMounting', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/mounting`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * <!-- theme: danger -->  > **Experimental**  Get the complete configuration which can be passed to the planner-optimizer (incl. motion group description, limits etc.)
-         * @summary Optimizer Configuration
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {string} [tcp]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getOptimizerConfiguration: async (cell, motionGroup, tcp, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getOptimizerConfiguration', 'cell', cell);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('getOptimizerConfiguration', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/optimizer-setup`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (tcp !== undefined) {
-                localVarQueryParameter['tcp'] = tcp;
-            }
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Get the safety setup and limitations of a connected motion group.  Safety settings are configured per robot controller and are valid for all connected motion groups.
-         * @summary Safety Setup and Limitations
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getSafetySetup: async (cell, motionGroup, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getSafetySetup', 'cell', cell);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('getSafetySetup', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/safety-setup`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Lists all defined payloads of the motion group. The payload is defined as the sum of all weights attached to the flange/endpoint of the motion group, e.g. sum of the tools and workpiece weight that are currently attached.
-         * @summary List Payloads
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        listPayloads: async (cell, motionGroup, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('listPayloads', 'cell', cell);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('listPayloads', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/payloads`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Get all internal configured TCPs of a connected device.  Use parameter orientation_type to get the orientation part of the transformation offset returned in the requested orientation notation. If parameter orientation_type is not set, the orientation part of the transformation offset is returned in rotation vector notation. If use_controller_orientation is set to true the orientation type used on the robot controller is used and the may specified orientation_type is ignored. This can be useful for visualization purposes in the client application due to equivalent numbers with robot control panel visualization.
-         * @summary List TCPs
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {OrientationType} [orientationType]
-         * @param {boolean} [useControllerOrientation]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        listTcps: async (cell, motionGroup, orientationType, useControllerOrientation, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('listTcps', 'cell', cell);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('listTcps', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/tcps`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (orientationType !== undefined) {
-                localVarQueryParameter['orientation_type'] = orientationType;
-            }
-            if (useControllerOrientation !== undefined) {
-                localVarQueryParameter['use_controller_orientation'] = useControllerOrientation;
-            }
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected.
-         * @summary Stream State of Device
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {number} [responseRate] Update rate for the response message in milliseconds (ms). Default is 200 ms. We recommend to use the step rate of the controller or a multiple of the step rate as NOVA updates the state in the controller\&#39;s step rate as well. Minimal response rate is the step rate of controller.
-         * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default is the world coordinate system.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        streamMotionGroupState: async (cell, motionGroup, responseRate, responseCoordinateSystem, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('streamMotionGroupState', 'cell', cell);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('streamMotionGroupState', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/state-stream`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (responseRate !== undefined) {
-                localVarQueryParameter['response_rate'] = responseRate;
-            }
-            if (responseCoordinateSystem !== undefined) {
-                localVarQueryParameter['response_coordinate_system'] = responseCoordinateSystem;
-            }
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-    };
-};
-/**
- * MotionGroupInfoApi - functional programming interface
- * @export
- */
-export const MotionGroupInfoApiFp = function (configuration) {
-    const localVarAxiosParamCreator = MotionGroupInfoApiAxiosParamCreator(configuration);
-    return {
-        /**
-         * Gets the currently selected payload of the motion group. The payload is defined as the sum of all weights attached to the flange/endpoint of the motion group, e.g. sum of the tools and workpiece weight that are currently attached.
-         * @summary Selected Payload
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getActivePayload(cell, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getActivePayload(cell, motionGroup, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupInfoApi.getActivePayload']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Get the internal selected TCP of a connected device.  Use parameter orientation_type to get the orientation part of the transformation offset returned in the requested orientation notation. If parameter orientation_type is not set, the orientation part of the transformation offset is returned in rotation vector notation. If use_controller_orientation is set to true the orientation type used on the robot controller is used and the may specified orientation_type is ignored. This can be useful for visualization purposes in the client application due to equivalent numbers with robot control panel visualization.
-         * @summary Selected TCP
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {OrientationType} [orientationType]
-         * @param {boolean} [useControllerOrientation]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getActiveTcp(cell, motionGroup, orientationType, useControllerOrientation, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getActiveTcp(cell, motionGroup, orientationType, useControllerOrientation, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupInfoApi.getActiveTcp']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Returns the current state of the selected motion group including the current joint position, velocity, pose, and more.
-         * @summary State of Device
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the responses should be converted. If not set, world coordinate system is used.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupInfoApi.getCurrentMotionGroupState']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Lists options the motion group offers in regard to the information service.  Some motion groups may not provide all information services, e.g. some manufacturers don\'t have a blending zone concept.
-         * @summary Capabilities
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getInfoCapabilities(cell, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getInfoCapabilities(cell, motionGroup, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupInfoApi.getInfoCapabilities']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Lists options the motion group offers in regard to jogging.  Some motion groups may not provide all information services, e.g. it is physically not possible to move a one-axis-turntable in a linear way.
-         * @summary Jogging Capabilities
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getJoggingCapabilities(cell, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getJoggingCapabilities(cell, motionGroup, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupInfoApi.getJoggingCapabilities']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Get static properties of the motion group. Those properties are used internally for motion group plannning. Only supported motion groups will return a valid response.
-         * @summary Get Static Properties
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getMotionGroupSpecification(cell, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getMotionGroupSpecification(cell, motionGroup, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupInfoApi.getMotionGroupSpecification']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Returns the configured mounting pose offset in relation to world coordinate system and the motion group\'s coordinate system.
-         * @summary Device Mounting
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getMounting(cell, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getMounting(cell, motionGroup, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupInfoApi.getMounting']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * <!-- theme: danger -->  > **Experimental**  Get the complete configuration which can be passed to the planner-optimizer (incl. motion group description, limits etc.)
-         * @summary Optimizer Configuration
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {string} [tcp]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getOptimizerConfiguration(cell, motionGroup, tcp, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getOptimizerConfiguration(cell, motionGroup, tcp, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupInfoApi.getOptimizerConfiguration']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Get the safety setup and limitations of a connected motion group.  Safety settings are configured per robot controller and are valid for all connected motion groups.
-         * @summary Safety Setup and Limitations
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getSafetySetup(cell, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getSafetySetup(cell, motionGroup, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupInfoApi.getSafetySetup']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Lists all defined payloads of the motion group. The payload is defined as the sum of all weights attached to the flange/endpoint of the motion group, e.g. sum of the tools and workpiece weight that are currently attached.
-         * @summary List Payloads
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async listPayloads(cell, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listPayloads(cell, motionGroup, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupInfoApi.listPayloads']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Get all internal configured TCPs of a connected device.  Use parameter orientation_type to get the orientation part of the transformation offset returned in the requested orientation notation. If parameter orientation_type is not set, the orientation part of the transformation offset is returned in rotation vector notation. If use_controller_orientation is set to true the orientation type used on the robot controller is used and the may specified orientation_type is ignored. This can be useful for visualization purposes in the client application due to equivalent numbers with robot control panel visualization.
-         * @summary List TCPs
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {OrientationType} [orientationType]
-         * @param {boolean} [useControllerOrientation]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async listTcps(cell, motionGroup, orientationType, useControllerOrientation, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listTcps(cell, motionGroup, orientationType, useControllerOrientation, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupInfoApi.listTcps']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected.
-         * @summary Stream State of Device
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {number} [responseRate] Update rate for the response message in milliseconds (ms). Default is 200 ms. We recommend to use the step rate of the controller or a multiple of the step rate as NOVA updates the state in the controller\&#39;s step rate as well. Minimal response rate is the step rate of controller.
-         * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default is the world coordinate system.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupInfoApi.streamMotionGroupState']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-    };
-};
-/**
- * MotionGroupInfoApi - factory interface
- * @export
- */
-export const MotionGroupInfoApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = MotionGroupInfoApiFp(configuration);
-    return {
-        /**
-         * Gets the currently selected payload of the motion group. The payload is defined as the sum of all weights attached to the flange/endpoint of the motion group, e.g. sum of the tools and workpiece weight that are currently attached.
-         * @summary Selected Payload
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getActivePayload(cell, motionGroup, options) {
-            return localVarFp.getActivePayload(cell, motionGroup, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Get the internal selected TCP of a connected device.  Use parameter orientation_type to get the orientation part of the transformation offset returned in the requested orientation notation. If parameter orientation_type is not set, the orientation part of the transformation offset is returned in rotation vector notation. If use_controller_orientation is set to true the orientation type used on the robot controller is used and the may specified orientation_type is ignored. This can be useful for visualization purposes in the client application due to equivalent numbers with robot control panel visualization.
-         * @summary Selected TCP
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {OrientationType} [orientationType]
-         * @param {boolean} [useControllerOrientation]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getActiveTcp(cell, motionGroup, orientationType, useControllerOrientation, options) {
-            return localVarFp.getActiveTcp(cell, motionGroup, orientationType, useControllerOrientation, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Returns the current state of the selected motion group including the current joint position, velocity, pose, and more.
-         * @summary State of Device
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the responses should be converted. If not set, world coordinate system is used.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options) {
-            return localVarFp.getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Lists options the motion group offers in regard to the information service.  Some motion groups may not provide all information services, e.g. some manufacturers don\'t have a blending zone concept.
-         * @summary Capabilities
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getInfoCapabilities(cell, motionGroup, options) {
-            return localVarFp.getInfoCapabilities(cell, motionGroup, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Lists options the motion group offers in regard to jogging.  Some motion groups may not provide all information services, e.g. it is physically not possible to move a one-axis-turntable in a linear way.
-         * @summary Jogging Capabilities
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getJoggingCapabilities(cell, motionGroup, options) {
-            return localVarFp.getJoggingCapabilities(cell, motionGroup, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Get static properties of the motion group. Those properties are used internally for motion group plannning. Only supported motion groups will return a valid response.
-         * @summary Get Static Properties
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getMotionGroupSpecification(cell, motionGroup, options) {
-            return localVarFp.getMotionGroupSpecification(cell, motionGroup, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Returns the configured mounting pose offset in relation to world coordinate system and the motion group\'s coordinate system.
-         * @summary Device Mounting
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getMounting(cell, motionGroup, options) {
-            return localVarFp.getMounting(cell, motionGroup, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * <!-- theme: danger -->  > **Experimental**  Get the complete configuration which can be passed to the planner-optimizer (incl. motion group description, limits etc.)
-         * @summary Optimizer Configuration
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {string} [tcp]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getOptimizerConfiguration(cell, motionGroup, tcp, options) {
-            return localVarFp.getOptimizerConfiguration(cell, motionGroup, tcp, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Get the safety setup and limitations of a connected motion group.  Safety settings are configured per robot controller and are valid for all connected motion groups.
-         * @summary Safety Setup and Limitations
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getSafetySetup(cell, motionGroup, options) {
-            return localVarFp.getSafetySetup(cell, motionGroup, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Lists all defined payloads of the motion group. The payload is defined as the sum of all weights attached to the flange/endpoint of the motion group, e.g. sum of the tools and workpiece weight that are currently attached.
-         * @summary List Payloads
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        listPayloads(cell, motionGroup, options) {
-            return localVarFp.listPayloads(cell, motionGroup, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Get all internal configured TCPs of a connected device.  Use parameter orientation_type to get the orientation part of the transformation offset returned in the requested orientation notation. If parameter orientation_type is not set, the orientation part of the transformation offset is returned in rotation vector notation. If use_controller_orientation is set to true the orientation type used on the robot controller is used and the may specified orientation_type is ignored. This can be useful for visualization purposes in the client application due to equivalent numbers with robot control panel visualization.
-         * @summary List TCPs
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {OrientationType} [orientationType]
-         * @param {boolean} [useControllerOrientation]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        listTcps(cell, motionGroup, orientationType, useControllerOrientation, options) {
-            return localVarFp.listTcps(cell, motionGroup, orientationType, useControllerOrientation, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected.
-         * @summary Stream State of Device
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {number} [responseRate] Update rate for the response message in milliseconds (ms). Default is 200 ms. We recommend to use the step rate of the controller or a multiple of the step rate as NOVA updates the state in the controller\&#39;s step rate as well. Minimal response rate is the step rate of controller.
-         * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default is the world coordinate system.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options) {
-            return localVarFp.streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options).then((request) => request(axios, basePath));
-        },
-    };
-};
-/**
- * MotionGroupInfoApi - object-oriented interface
- * @export
- * @class MotionGroupInfoApi
- * @extends {BaseAPI}
- */
-export class MotionGroupInfoApi extends BaseAPI {
-    /**
-     * Gets the currently selected payload of the motion group. The payload is defined as the sum of all weights attached to the flange/endpoint of the motion group, e.g. sum of the tools and workpiece weight that are currently attached.
-     * @summary Selected Payload
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} motionGroup The motion-group identifier.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupInfoApi
-     */
-    getActivePayload(cell, motionGroup, options) {
-        return MotionGroupInfoApiFp(this.configuration).getActivePayload(cell, motionGroup, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Get the internal selected TCP of a connected device.  Use parameter orientation_type to get the orientation part of the transformation offset returned in the requested orientation notation. If parameter orientation_type is not set, the orientation part of the transformation offset is returned in rotation vector notation. If use_controller_orientation is set to true the orientation type used on the robot controller is used and the may specified orientation_type is ignored. This can be useful for visualization purposes in the client application due to equivalent numbers with robot control panel visualization.
-     * @summary Selected TCP
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} motionGroup The motion-group identifier.
-     * @param {OrientationType} [orientationType]
-     * @param {boolean} [useControllerOrientation]
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupInfoApi
-     */
-    getActiveTcp(cell, motionGroup, orientationType, useControllerOrientation, options) {
-        return MotionGroupInfoApiFp(this.configuration).getActiveTcp(cell, motionGroup, orientationType, useControllerOrientation, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Returns the current state of the selected motion group including the current joint position, velocity, pose, and more.
-     * @summary State of Device
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} motionGroup The motion-group identifier.
-     * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the responses should be converted. If not set, world coordinate system is used.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupInfoApi
-     */
-    getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options) {
-        return MotionGroupInfoApiFp(this.configuration).getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Lists options the motion group offers in regard to the information service.  Some motion groups may not provide all information services, e.g. some manufacturers don\'t have a blending zone concept.
-     * @summary Capabilities
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} motionGroup The motion-group identifier.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupInfoApi
-     */
-    getInfoCapabilities(cell, motionGroup, options) {
-        return MotionGroupInfoApiFp(this.configuration).getInfoCapabilities(cell, motionGroup, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Lists options the motion group offers in regard to jogging.  Some motion groups may not provide all information services, e.g. it is physically not possible to move a one-axis-turntable in a linear way.
-     * @summary Jogging Capabilities
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} motionGroup The motion-group identifier.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupInfoApi
-     */
-    getJoggingCapabilities(cell, motionGroup, options) {
-        return MotionGroupInfoApiFp(this.configuration).getJoggingCapabilities(cell, motionGroup, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Get static properties of the motion group. Those properties are used internally for motion group plannning. Only supported motion groups will return a valid response.
-     * @summary Get Static Properties
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} motionGroup The motion-group identifier.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupInfoApi
-     */
-    getMotionGroupSpecification(cell, motionGroup, options) {
-        return MotionGroupInfoApiFp(this.configuration).getMotionGroupSpecification(cell, motionGroup, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Returns the configured mounting pose offset in relation to world coordinate system and the motion group\'s coordinate system.
-     * @summary Device Mounting
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} motionGroup The motion-group identifier.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupInfoApi
-     */
-    getMounting(cell, motionGroup, options) {
-        return MotionGroupInfoApiFp(this.configuration).getMounting(cell, motionGroup, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * <!-- theme: danger -->  > **Experimental**  Get the complete configuration which can be passed to the planner-optimizer (incl. motion group description, limits etc.)
-     * @summary Optimizer Configuration
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} motionGroup The motion-group identifier.
-     * @param {string} [tcp]
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupInfoApi
-     */
-    getOptimizerConfiguration(cell, motionGroup, tcp, options) {
-        return MotionGroupInfoApiFp(this.configuration).getOptimizerConfiguration(cell, motionGroup, tcp, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Get the safety setup and limitations of a connected motion group.  Safety settings are configured per robot controller and are valid for all connected motion groups.
-     * @summary Safety Setup and Limitations
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} motionGroup The motion-group identifier.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupInfoApi
-     */
-    getSafetySetup(cell, motionGroup, options) {
-        return MotionGroupInfoApiFp(this.configuration).getSafetySetup(cell, motionGroup, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Lists all defined payloads of the motion group. The payload is defined as the sum of all weights attached to the flange/endpoint of the motion group, e.g. sum of the tools and workpiece weight that are currently attached.
-     * @summary List Payloads
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} motionGroup The motion-group identifier.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupInfoApi
-     */
-    listPayloads(cell, motionGroup, options) {
-        return MotionGroupInfoApiFp(this.configuration).listPayloads(cell, motionGroup, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Get all internal configured TCPs of a connected device.  Use parameter orientation_type to get the orientation part of the transformation offset returned in the requested orientation notation. If parameter orientation_type is not set, the orientation part of the transformation offset is returned in rotation vector notation. If use_controller_orientation is set to true the orientation type used on the robot controller is used and the may specified orientation_type is ignored. This can be useful for visualization purposes in the client application due to equivalent numbers with robot control panel visualization.
-     * @summary List TCPs
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} motionGroup The motion-group identifier.
-     * @param {OrientationType} [orientationType]
-     * @param {boolean} [useControllerOrientation]
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupInfoApi
-     */
-    listTcps(cell, motionGroup, orientationType, useControllerOrientation, options) {
-        return MotionGroupInfoApiFp(this.configuration).listTcps(cell, motionGroup, orientationType, useControllerOrientation, options).then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected.
-     * @summary Stream State of Device
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} motionGroup The motion-group identifier.
-     * @param {number} [responseRate] Update rate for the response message in milliseconds (ms). Default is 200 ms. We recommend to use the step rate of the controller or a multiple of the step rate as NOVA updates the state in the controller\&#39;s step rate as well. Minimal response rate is the step rate of controller.
-     * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default is the world coordinate system.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupInfoApi
-     */
-    streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options) {
-        return MotionGroupInfoApiFp(this.configuration).streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options).then((request) => request(this.axios, this.basePath));
-    }
-}
-/**
- * MotionGroupKinematicsApi - axios parameter creator
- * @export
- */
-export const MotionGroupKinematicsApiAxiosParamCreator = function (configuration) {
-    return {
-        /**
-         * Calculate the joint positions of a motion group in order to move its TCP to a specific pose (Inverse Kinematic Solutions). All solutions are within the configured joint limits of the robot and not in a singular position of the robot.  Return all joint positions as list of distinct joint positions in [rad] with their respective inverse feedback.  Will be empty when unreachable, e.g. outside joint position limits, singular.  Does not include multiple solutions where the robot links are in the same postition. Those can occur when single joints are allowed to move in a range larger than 360 degrees.
-         * @summary All Joint Positions from TCP Pose
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {AllJointPositionsRequest} allJointPositionsRequest
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        calculateAllInverseKinematic: async (cell, motionGroup, allJointPositionsRequest, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('calculateAllInverseKinematic', 'cell', cell);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('calculateAllInverseKinematic', 'motionGroup', motionGroup);
-            // verify required parameter 'allJointPositionsRequest' is not null or undefined
-            assertParamExists('calculateAllInverseKinematic', 'allJointPositionsRequest', allJointPositionsRequest);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/kinematic/calculate-all-joint-positions`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            localVarHeaderParameter['Content-Type'] = 'application/json';
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            localVarRequestOptions.data = serializeDataIfNeeded(allJointPositionsRequest, localVarRequestOptions, configuration);
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Calculates the TCP pose from a joint position sample using the forward kinematics of the motion-group.
-         * @summary TCP Pose from Joint Position
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {TcpPoseRequest} tcpPoseRequest
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        calculateForwardKinematic: async (cell, motionGroup, tcpPoseRequest, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('calculateForwardKinematic', 'cell', cell);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('calculateForwardKinematic', 'motionGroup', motionGroup);
-            // verify required parameter 'tcpPoseRequest' is not null or undefined
-            assertParamExists('calculateForwardKinematic', 'tcpPoseRequest', tcpPoseRequest);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/kinematic/calculate-tcp-pose`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            localVarHeaderParameter['Content-Type'] = 'application/json';
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            localVarRequestOptions.data = serializeDataIfNeeded(tcpPoseRequest, localVarRequestOptions, configuration);
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Calculate the joint positions the motion-group needs to apply for its TCP to be in a specified pose (Inverse Kinematic Solution).  If multiple solutions are found, the one nearest to the given specified joint position is picked. * For all supported robot models, except the Fanuc CRX line, the returned joint position is guaranteed to have the same configuration (often referred to as ELBOW_UP, WRIST_DOWN, SHOULDER_RIGHT, f.e.) as the specified reference joint position. If the position limit of any single joint allows it to be in a range larger than 2 PI, the respective joint value in the result will be as close as possible to its reference value. * For the Fanuc CRX line the solution is selected to have the smallest distance measured by the norm of its difference to the reference joint position.  The returned joint position is guaranteed to be within the joint limits and not in a singular position of the robot.
-         * @summary Nearest Joint Position from TCP Pose
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {JointPositionRequest} jointPositionRequest
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        calculateInverseKinematic: async (cell, motionGroup, jointPositionRequest, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('calculateInverseKinematic', 'cell', cell);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('calculateInverseKinematic', 'motionGroup', motionGroup);
-            // verify required parameter 'jointPositionRequest' is not null or undefined
-            assertParamExists('calculateInverseKinematic', 'jointPositionRequest', jointPositionRequest);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/kinematic/calculate-joint-position`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            localVarHeaderParameter['Content-Type'] = 'application/json';
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            localVarRequestOptions.data = serializeDataIfNeeded(jointPositionRequest, localVarRequestOptions, configuration);
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Get the kinematic endpoints provided for the specified motion-group.
-         * @summary Capabilities
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getKinematicCapabilities: async (cell, motionGroup, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getKinematicCapabilities', 'cell', cell);
-            // verify required parameter 'motionGroup' is not null or undefined
-            assertParamExists('getKinematicCapabilities', 'motionGroup', motionGroup);
-            const localVarPath = `/cells/{cell}/motion-groups/{motion-group}/kinematic-capabilities`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group"}}`, encodeURIComponent(String(motionGroup)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-    };
-};
-/**
- * MotionGroupKinematicsApi - functional programming interface
- * @export
- */
-export const MotionGroupKinematicsApiFp = function (configuration) {
-    const localVarAxiosParamCreator = MotionGroupKinematicsApiAxiosParamCreator(configuration);
-    return {
-        /**
-         * Calculate the joint positions of a motion group in order to move its TCP to a specific pose (Inverse Kinematic Solutions). All solutions are within the configured joint limits of the robot and not in a singular position of the robot.  Return all joint positions as list of distinct joint positions in [rad] with their respective inverse feedback.  Will be empty when unreachable, e.g. outside joint position limits, singular.  Does not include multiple solutions where the robot links are in the same postition. Those can occur when single joints are allowed to move in a range larger than 360 degrees.
-         * @summary All Joint Positions from TCP Pose
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {AllJointPositionsRequest} allJointPositionsRequest
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async calculateAllInverseKinematic(cell, motionGroup, allJointPositionsRequest, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.calculateAllInverseKinematic(cell, motionGroup, allJointPositionsRequest, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupKinematicsApi.calculateAllInverseKinematic']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * Calculates the TCP pose from a joint position sample using the forward kinematics of the motion-group.
-         * @summary TCP Pose from Joint Position
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {TcpPoseRequest} tcpPoseRequest
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async calculateForwardKinematic(cell, motionGroup, tcpPoseRequest, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.calculateForwardKinematic(cell, motionGroup, tcpPoseRequest, options);
+        async getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupKinematicsApi.calculateForwardKinematic']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['MotionGroupApi.getCurrentMotionGroupState']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Calculate the joint positions the motion-group needs to apply for its TCP to be in a specified pose (Inverse Kinematic Solution).  If multiple solutions are found, the one nearest to the given specified joint position is picked. * For all supported robot models, except the Fanuc CRX line, the returned joint position is guaranteed to have the same configuration (often referred to as ELBOW_UP, WRIST_DOWN, SHOULDER_RIGHT, f.e.) as the specified reference joint position. If the position limit of any single joint allows it to be in a range larger than 2 PI, the respective joint value in the result will be as close as possible to its reference value. * For the Fanuc CRX line the solution is selected to have the smallest distance measured by the norm of its difference to the reference joint position.  The returned joint position is guaranteed to be within the joint limits and not in a singular position of the robot.
-         * @summary Nearest Joint Position from TCP Pose
+         * Get the complete set of parameters that can be passed to the motion-planner (incl. safety zones, limits etc.).
+         * @summary Planning Parameters
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} motionGroup The motion-group identifier.
-         * @param {JointPositionRequest} jointPositionRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async calculateInverseKinematic(cell, motionGroup, jointPositionRequest, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.calculateInverseKinematic(cell, motionGroup, jointPositionRequest, options);
+        async getPlanningParameters(cell, motionGroup, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getPlanningParameters(cell, motionGroup, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupKinematicsApi.calculateInverseKinematic']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['MotionGroupApi.getPlanningParameters']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Get the kinematic endpoints provided for the specified motion-group.
-         * @summary Capabilities
+         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected.
+         * @summary Stream State
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} motionGroup The motion-group identifier.
+         * @param {number} [responseRate] Update rate for the response message in milliseconds (ms). Default is 200 ms. We recommend to use the step rate of the controller or a multiple of the step rate as NOVA updates the state in the controller\&#39;s step rate as well. Minimal response rate is the step rate of controller.
+         * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default is the world coordinate system.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async getKinematicCapabilities(cell, motionGroup, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getKinematicCapabilities(cell, motionGroup, options);
+        async streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MotionGroupKinematicsApi.getKinematicCapabilities']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['MotionGroupApi.streamMotionGroupState']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     };
 };
 /**
- * MotionGroupKinematicsApi - factory interface
+ * MotionGroupApi - factory interface
  * @export
  */
-export const MotionGroupKinematicsApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = MotionGroupKinematicsApiFp(configuration);
+export const MotionGroupApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = MotionGroupApiFp(configuration);
     return {
         /**
-         * Calculate the joint positions of a motion group in order to move its TCP to a specific pose (Inverse Kinematic Solutions). All solutions are within the configured joint limits of the robot and not in a singular position of the robot.  Return all joint positions as list of distinct joint positions in [rad] with their respective inverse feedback.  Will be empty when unreachable, e.g. outside joint position limits, singular.  Does not include multiple solutions where the robot links are in the same postition. Those can occur when single joints are allowed to move in a range larger than 360 degrees.
-         * @summary All Joint Positions from TCP Pose
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} motionGroup The motion-group identifier.
-         * @param {AllJointPositionsRequest} allJointPositionsRequest
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        calculateAllInverseKinematic(cell, motionGroup, allJointPositionsRequest, options) {
-            return localVarFp.calculateAllInverseKinematic(cell, motionGroup, allJointPositionsRequest, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * Calculates the TCP pose from a joint position sample using the forward kinematics of the motion-group.
-         * @summary TCP Pose from Joint Position
+         * Returns the current state of the selected motion group including the current joint position, velocity, pose, and more.
+         * @summary State
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} motionGroup The motion-group identifier.
-         * @param {TcpPoseRequest} tcpPoseRequest
+         * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the responses should be converted. If not set, world coordinate system is used.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        calculateForwardKinematic(cell, motionGroup, tcpPoseRequest, options) {
-            return localVarFp.calculateForwardKinematic(cell, motionGroup, tcpPoseRequest, options).then((request) => request(axios, basePath));
+        getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options) {
+            return localVarFp.getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options).then((request) => request(axios, basePath));
         },
         /**
-         * Calculate the joint positions the motion-group needs to apply for its TCP to be in a specified pose (Inverse Kinematic Solution).  If multiple solutions are found, the one nearest to the given specified joint position is picked. * For all supported robot models, except the Fanuc CRX line, the returned joint position is guaranteed to have the same configuration (often referred to as ELBOW_UP, WRIST_DOWN, SHOULDER_RIGHT, f.e.) as the specified reference joint position. If the position limit of any single joint allows it to be in a range larger than 2 PI, the respective joint value in the result will be as close as possible to its reference value. * For the Fanuc CRX line the solution is selected to have the smallest distance measured by the norm of its difference to the reference joint position.  The returned joint position is guaranteed to be within the joint limits and not in a singular position of the robot.
-         * @summary Nearest Joint Position from TCP Pose
+         * Get the complete set of parameters that can be passed to the motion-planner (incl. safety zones, limits etc.).
+         * @summary Planning Parameters
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} motionGroup The motion-group identifier.
-         * @param {JointPositionRequest} jointPositionRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        calculateInverseKinematic(cell, motionGroup, jointPositionRequest, options) {
-            return localVarFp.calculateInverseKinematic(cell, motionGroup, jointPositionRequest, options).then((request) => request(axios, basePath));
+        getPlanningParameters(cell, motionGroup, options) {
+            return localVarFp.getPlanningParameters(cell, motionGroup, options).then((request) => request(axios, basePath));
         },
         /**
-         * Get the kinematic endpoints provided for the specified motion-group.
-         * @summary Capabilities
+         * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected.
+         * @summary Stream State
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} motionGroup The motion-group identifier.
+         * @param {number} [responseRate] Update rate for the response message in milliseconds (ms). Default is 200 ms. We recommend to use the step rate of the controller or a multiple of the step rate as NOVA updates the state in the controller\&#39;s step rate as well. Minimal response rate is the step rate of controller.
+         * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default is the world coordinate system.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getKinematicCapabilities(cell, motionGroup, options) {
-            return localVarFp.getKinematicCapabilities(cell, motionGroup, options).then((request) => request(axios, basePath));
+        streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options) {
+            return localVarFp.streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options).then((request) => request(axios, basePath));
         },
     };
 };
 /**
- * MotionGroupKinematicsApi - object-oriented interface
+ * MotionGroupApi - object-oriented interface
  * @export
- * @class MotionGroupKinematicsApi
+ * @class MotionGroupApi
  * @extends {BaseAPI}
  */
-export class MotionGroupKinematicsApi extends BaseAPI {
-    /**
-     * Calculate the joint positions of a motion group in order to move its TCP to a specific pose (Inverse Kinematic Solutions). All solutions are within the configured joint limits of the robot and not in a singular position of the robot.  Return all joint positions as list of distinct joint positions in [rad] with their respective inverse feedback.  Will be empty when unreachable, e.g. outside joint position limits, singular.  Does not include multiple solutions where the robot links are in the same postition. Those can occur when single joints are allowed to move in a range larger than 360 degrees.
-     * @summary All Joint Positions from TCP Pose
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {string} motionGroup The motion-group identifier.
-     * @param {AllJointPositionsRequest} allJointPositionsRequest
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MotionGroupKinematicsApi
-     */
-    calculateAllInverseKinematic(cell, motionGroup, allJointPositionsRequest, options) {
-        return MotionGroupKinematicsApiFp(this.configuration).calculateAllInverseKinematic(cell, motionGroup, allJointPositionsRequest, options).then((request) => request(this.axios, this.basePath));
-    }
+export class MotionGroupApi extends BaseAPI {
     /**
-     * Calculates the TCP pose from a joint position sample using the forward kinematics of the motion-group.
-     * @summary TCP Pose from Joint Position
+     * Returns the current state of the selected motion group including the current joint position, velocity, pose, and more.
+     * @summary State
      * @param {string} cell Unique identifier addressing a cell in all API calls.
      * @param {string} motionGroup The motion-group identifier.
-     * @param {TcpPoseRequest} tcpPoseRequest
+     * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the responses should be converted. If not set, world coordinate system is used.
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof MotionGroupKinematicsApi
+     * @memberof MotionGroupApi
      */
-    calculateForwardKinematic(cell, motionGroup, tcpPoseRequest, options) {
-        return MotionGroupKinematicsApiFp(this.configuration).calculateForwardKinematic(cell, motionGroup, tcpPoseRequest, options).then((request) => request(this.axios, this.basePath));
+    getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options) {
+        return MotionGroupApiFp(this.configuration).getCurrentMotionGroupState(cell, motionGroup, responseCoordinateSystem, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Calculate the joint positions the motion-group needs to apply for its TCP to be in a specified pose (Inverse Kinematic Solution).  If multiple solutions are found, the one nearest to the given specified joint position is picked. * For all supported robot models, except the Fanuc CRX line, the returned joint position is guaranteed to have the same configuration (often referred to as ELBOW_UP, WRIST_DOWN, SHOULDER_RIGHT, f.e.) as the specified reference joint position. If the position limit of any single joint allows it to be in a range larger than 2 PI, the respective joint value in the result will be as close as possible to its reference value. * For the Fanuc CRX line the solution is selected to have the smallest distance measured by the norm of its difference to the reference joint position.  The returned joint position is guaranteed to be within the joint limits and not in a singular position of the robot.
-     * @summary Nearest Joint Position from TCP Pose
+     * Get the complete set of parameters that can be passed to the motion-planner (incl. safety zones, limits etc.).
+     * @summary Planning Parameters
      * @param {string} cell Unique identifier addressing a cell in all API calls.
      * @param {string} motionGroup The motion-group identifier.
-     * @param {JointPositionRequest} jointPositionRequest
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof MotionGroupKinematicsApi
+     * @memberof MotionGroupApi
      */
-    calculateInverseKinematic(cell, motionGroup, jointPositionRequest, options) {
-        return MotionGroupKinematicsApiFp(this.configuration).calculateInverseKinematic(cell, motionGroup, jointPositionRequest, options).then((request) => request(this.axios, this.basePath));
+    getPlanningParameters(cell, motionGroup, options) {
+        return MotionGroupApiFp(this.configuration).getPlanningParameters(cell, motionGroup, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Get the kinematic endpoints provided for the specified motion-group.
-     * @summary Capabilities
+     * <!-- theme: danger -->  > Websocket endpoint  Receive updates of the motion group state. The stream will be closed from the server if the controller is disconnected.
+     * @summary Stream State
      * @param {string} cell Unique identifier addressing a cell in all API calls.
      * @param {string} motionGroup The motion-group identifier.
+     * @param {number} [responseRate] Update rate for the response message in milliseconds (ms). Default is 200 ms. We recommend to use the step rate of the controller or a multiple of the step rate as NOVA updates the state in the controller\&#39;s step rate as well. Minimal response rate is the step rate of controller.
+     * @param {string} [responseCoordinateSystem] Unique identifier addressing a coordinate system to which the cartesian data of the responses should be converted. Default is the world coordinate system.
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof MotionGroupKinematicsApi
+     * @memberof MotionGroupApi
      */
-    getKinematicCapabilities(cell, motionGroup, options) {
-        return MotionGroupKinematicsApiFp(this.configuration).getKinematicCapabilities(cell, motionGroup, options).then((request) => request(this.axios, this.basePath));
+    streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options) {
+        return MotionGroupApiFp(this.configuration).streamMotionGroupState(cell, motionGroup, responseRate, responseCoordinateSystem, options).then((request) => request(this.axios, this.basePath));
     }
 }
 /**
@@ -7301,45 +5433,6 @@ export const StoreCollisionComponentsApiAxiosParamCreator = function (configurat
                 options: localVarRequestOptions,
             };
         },
-        /**
-         * Returns the default collision link chain for a given motion group model.  See [getPlanningMotionGroupModels](getPlanningMotionGroupModels) for supported motion group models.  The default link chain is derived from 3D models and optimized for collision detection within NOVA.  The default link chain includes link shapes only. It does not include any attached components like wire feeders or sensors.  Use the `stored_link_chain` or `link_chain` field in [storeCollisionScene](storeCollisionScene) to attach additional shapes to the link reference frames. Additional shapes may overlap each other per link and may also overlap the respective link\'s default shape.
-         * @summary Get Default Link Chain
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {MotionGroupModel} motionGroupModel Unique identifier for the model of a motion group, e.g. &#x60;UniversalRobots_UR10e&#x60;.  Get the &#x60;model&#x60; of a configured motion group with [getOptimizerConfiguration](getOptimizerConfiguration).
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getDefaultLinkChain: async (cell, motionGroupModel, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getDefaultLinkChain', 'cell', cell);
-            // verify required parameter 'motionGroupModel' is not null or undefined
-            assertParamExists('getDefaultLinkChain', 'motionGroupModel', motionGroupModel);
-            const localVarPath = `/cells/{cell}/store/collision/default-link-chains/{motion-group-model}`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"motion-group-model"}}`, encodeURIComponent(String(motionGroupModel)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
         /**
          * Returns the collider.
          * @summary Get Collider
@@ -7745,20 +5838,6 @@ export const StoreCollisionComponentsApiFp = function (configuration) {
             const localVarOperationServerBasePath = operationServerMap['StoreCollisionComponentsApi.deleteStoredCollisionTool']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
-        /**
-         * Returns the default collision link chain for a given motion group model.  See [getPlanningMotionGroupModels](getPlanningMotionGroupModels) for supported motion group models.  The default link chain is derived from 3D models and optimized for collision detection within NOVA.  The default link chain includes link shapes only. It does not include any attached components like wire feeders or sensors.  Use the `stored_link_chain` or `link_chain` field in [storeCollisionScene](storeCollisionScene) to attach additional shapes to the link reference frames. Additional shapes may overlap each other per link and may also overlap the respective link\'s default shape.
-         * @summary Get Default Link Chain
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {MotionGroupModel} motionGroupModel Unique identifier for the model of a motion group, e.g. &#x60;UniversalRobots_UR10e&#x60;.  Get the &#x60;model&#x60; of a configured motion group with [getOptimizerConfiguration](getOptimizerConfiguration).
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getDefaultLinkChain(cell, motionGroupModel, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getDefaultLinkChain(cell, motionGroupModel, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['StoreCollisionComponentsApi.getDefaultLinkChain']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
         /**
          * Returns the collider.
          * @summary Get Collider
@@ -7927,17 +6006,6 @@ export const StoreCollisionComponentsApiFactory = function (configuration, baseP
         deleteStoredCollisionTool(cell, tool, options) {
             return localVarFp.deleteStoredCollisionTool(cell, tool, options).then((request) => request(axios, basePath));
         },
-        /**
-         * Returns the default collision link chain for a given motion group model.  See [getPlanningMotionGroupModels](getPlanningMotionGroupModels) for supported motion group models.  The default link chain is derived from 3D models and optimized for collision detection within NOVA.  The default link chain includes link shapes only. It does not include any attached components like wire feeders or sensors.  Use the `stored_link_chain` or `link_chain` field in [storeCollisionScene](storeCollisionScene) to attach additional shapes to the link reference frames. Additional shapes may overlap each other per link and may also overlap the respective link\'s default shape.
-         * @summary Get Default Link Chain
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {MotionGroupModel} motionGroupModel Unique identifier for the model of a motion group, e.g. &#x60;UniversalRobots_UR10e&#x60;.  Get the &#x60;model&#x60; of a configured motion group with [getOptimizerConfiguration](getOptimizerConfiguration).
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        getDefaultLinkChain(cell, motionGroupModel, options) {
-            return localVarFp.getDefaultLinkChain(cell, motionGroupModel, options).then((request) => request(axios, basePath));
-        },
         /**
          * Returns the collider.
          * @summary Get Collider
@@ -8082,18 +6150,6 @@ export class StoreCollisionComponentsApi extends BaseAPI {
     deleteStoredCollisionTool(cell, tool, options) {
         return StoreCollisionComponentsApiFp(this.configuration).deleteStoredCollisionTool(cell, tool, options).then((request) => request(this.axios, this.basePath));
     }
-    /**
-     * Returns the default collision link chain for a given motion group model.  See [getPlanningMotionGroupModels](getPlanningMotionGroupModels) for supported motion group models.  The default link chain is derived from 3D models and optimized for collision detection within NOVA.  The default link chain includes link shapes only. It does not include any attached components like wire feeders or sensors.  Use the `stored_link_chain` or `link_chain` field in [storeCollisionScene](storeCollisionScene) to attach additional shapes to the link reference frames. Additional shapes may overlap each other per link and may also overlap the respective link\'s default shape.
-     * @summary Get Default Link Chain
-     * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {MotionGroupModel} motionGroupModel Unique identifier for the model of a motion group, e.g. &#x60;UniversalRobots_UR10e&#x60;.  Get the &#x60;model&#x60; of a configured motion group with [getOptimizerConfiguration](getOptimizerConfiguration).
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof StoreCollisionComponentsApi
-     */
-    getDefaultLinkChain(cell, motionGroupModel, options) {
-        return StoreCollisionComponentsApiFp(this.configuration).getDefaultLinkChain(cell, motionGroupModel, options).then((request) => request(this.axios, this.basePath));
-    }
     /**
      * Returns the collider.
      * @summary Get Collider
@@ -9966,13 +8022,13 @@ export class SystemApi extends BaseAPI {
     }
 }
 /**
- * TrajectoryExecutionApi - axios parameter creator
+ * TrajectoryCachingApi - axios parameter creator
  * @export
  */
-export const TrajectoryExecutionApiAxiosParamCreator = function (configuration) {
+export const TrajectoryCachingApiAxiosParamCreator = function (configuration) {
     return {
         /**
-         * Loads and validates the data of a trajectory into the execution cache, rendering the trajectory executable. The response contains the result of the validation of the trajectory.  Validation can lead to three different results: - Fully valid: The whole trajectory can be executed from start to end. The response will contain an unique identifier which is used to move the robot. - Partially valid: Only parts of the trajectory can be executed. The response will contain an unique identifier to move the robot   and information about the failure for the part that is not executable. - Invalid: The trajectory can not be executed. The response will tell you the reason of failure.  If the trajectory is at least partially valid, the parts of the trajectory that are valid can be executed using the [executeTrajectory](executeTrajectory) endpoint.  The workflow is as follows:   - Generate a trajectory with [planTrajectory](planTrajectory) or your own motion planner,   - Send the trajectory to this endpoint to validate it and get a unique identifier for it,   - The unique identifier will appear in the list of available trajectories, see [listTrajectories](listTrajectories) endpoint, if it is at least partially executable.   - Move motion group to trajectory using the [executeToTrajectory](executeToTrajectory) endpoint.   - Execute your trajectory using the [executeTrajectory](executeTrajectory) endpoint.
+         * <!-- theme: info -->  > Using the trajectory cache is an optional performance optimization. It is not necessary to use the cache to execute trajectories.  Loads and validates the data of a trajectory into the execution cache, rendering the trajectory executable. The response contains the result of the validation of the trajectory.  Validation can lead to three different results: - Fully valid: The whole trajectory can be executed from start to end. The response will contain an unique identifier which is used to move the robot. - Partially valid: Only parts of the trajectory can be executed. The response will contain an unique identifier to move the robot   and information about the failure for the part that is not executable. - Invalid: The trajectory can not be executed. The response will tell you the reason of failure.  If the trajectory is at least partially valid, the parts of the trajectory that are valid can be executed using the [executeTrajectory](executeTrajectory) endpoint.  The workflow is as follows:   - Generate a trajectory with [planTrajectory](planTrajectory) or your own motion planner,   - Send the trajectory to this endpoint to validate it and get a unique identifier for it,   - The unique identifier will appear in the list of available trajectories, see [listTrajectories](listTrajectories) endpoint, if it is at least partially executable.   - Execute your trajectory using the [executeTrajectory](executeTrajectory) endpoint.
          * @summary Add Trajectory
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {AddTrajectoryRequest} addTrajectoryRequest
@@ -10047,68 +8103,19 @@ export const TrajectoryExecutionApiAxiosParamCreator = function (configuration)
             };
         },
         /**
-         * Delete a previously created trajectory from cache. Use [listTrajectories](listTrajectories) to list all cached trajectories. Trajectories are removed automatically if the motion group or the corresponding controller is disconnected.
-         * @summary Delete Trajectory
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory.
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        deleteTrajectory: async (cell, trajectory, options = {}) => {
-            // verify required parameter 'cell' is not null or undefined
-            assertParamExists('deleteTrajectory', 'cell', cell);
-            // verify required parameter 'trajectory' is not null or undefined
-            assertParamExists('deleteTrajectory', 'trajectory', trajectory);
-            const localVarPath = `/cells/{cell}/trajectories/{trajectory}`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"trajectory"}}`, encodeURIComponent(String(trajectory)));
-            // use dummy base URL string because the URL constructor only accepts absolute URLs.
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'DELETE', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            // authentication BasicAuth required
-            // http basic authentication required
-            setBasicAuthToObject(localVarRequestOptions, configuration);
-            // authentication BearerAuth required
-            // http bearer authentication required
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Request to move the motion group via joint point-to-point to a given location on a trajectory.  To start moving along a trajectory from an arbitrary location, the current joint positions must match the joint positions of the trajectory at the given location.  > **Note:** To abort the movement, the connection needs to be closed.
-         * @summary Move to Trajectory
+         * Delete a previously created trajectory from cache. Use [listTrajectories](listTrajectories) to list all cached trajectories. Trajectories are removed automatically if the motion group or the corresponding controller is disconnected.
+         * @summary Delete Trajectory
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory.
-         * @param {number} locationOnTrajectory
-         * @param {Array<number>} [overrideJointVelocityLimits] The joint velocity limits for the p2p movement to a previously added trajectory.
-         * @param {Array<number>} [overrideJointAccelerationLimits] The joint acceleration limits for the p2p movement to a previously added trajectory.
-         * @param {number} [overrideTcpVelocityLimit] Maximum allowed TCP velocity in [mm/s].
-         * @param {number} [overrideTcpAccelerationLimit] Maximum allowed TCP acceleration in [mm/s^2].
-         * @param {number} [overrideTcpOrientationVelocityLimit] Maximum allowed TCP rotation velocity in [rad/s].
-         * @param {number} [overrideTcpOrientationAccelerationLimit] Maximum allowed TCP rotation acceleration in [rad/s^2].
-         * @param {string} [responsesCoordinateSystem]
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        executeToTrajectory: async (cell, trajectory, locationOnTrajectory, overrideJointVelocityLimits, overrideJointAccelerationLimits, overrideTcpVelocityLimit, overrideTcpAccelerationLimit, overrideTcpOrientationVelocityLimit, overrideTcpOrientationAccelerationLimit, responsesCoordinateSystem, options = {}) => {
+        deleteTrajectory: async (cell, trajectory, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('executeToTrajectory', 'cell', cell);
+            assertParamExists('deleteTrajectory', 'cell', cell);
             // verify required parameter 'trajectory' is not null or undefined
-            assertParamExists('executeToTrajectory', 'trajectory', trajectory);
-            // verify required parameter 'locationOnTrajectory' is not null or undefined
-            assertParamExists('executeToTrajectory', 'locationOnTrajectory', locationOnTrajectory);
-            const localVarPath = `/cells/{cell}/trajectories/{trajectory}/execution/to-trajectory`
+            assertParamExists('deleteTrajectory', 'trajectory', trajectory);
+            const localVarPath = `/cells/{cell}/trajectories/{trajectory}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
                 .replace(`{${"trajectory"}}`, encodeURIComponent(String(trajectory)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -10117,7 +8124,7 @@ export const TrajectoryExecutionApiAxiosParamCreator = function (configuration)
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'DELETE', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BasicAuth required
@@ -10126,30 +8133,6 @@ export const TrajectoryExecutionApiAxiosParamCreator = function (configuration)
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (locationOnTrajectory !== undefined) {
-                localVarQueryParameter['location_on_trajectory'] = locationOnTrajectory;
-            }
-            if (overrideJointVelocityLimits) {
-                localVarQueryParameter['override_joint_velocity_limits'] = overrideJointVelocityLimits;
-            }
-            if (overrideJointAccelerationLimits) {
-                localVarQueryParameter['override_joint_acceleration_limits'] = overrideJointAccelerationLimits;
-            }
-            if (overrideTcpVelocityLimit !== undefined) {
-                localVarQueryParameter['override_tcp_velocity_limit'] = overrideTcpVelocityLimit;
-            }
-            if (overrideTcpAccelerationLimit !== undefined) {
-                localVarQueryParameter['override_tcp_acceleration_limit'] = overrideTcpAccelerationLimit;
-            }
-            if (overrideTcpOrientationVelocityLimit !== undefined) {
-                localVarQueryParameter['override_tcp_orientation_velocity_limit'] = overrideTcpOrientationVelocityLimit;
-            }
-            if (overrideTcpOrientationAccelerationLimit !== undefined) {
-                localVarQueryParameter['override_tcp_orientation_acceleration_limit'] = overrideTcpOrientationAccelerationLimit;
-            }
-            if (responsesCoordinateSystem !== undefined) {
-                localVarQueryParameter['responses_coordinate_system'] = responsesCoordinateSystem;
-            }
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -10159,20 +8142,21 @@ export const TrajectoryExecutionApiAxiosParamCreator = function (configuration)
             };
         },
         /**
-         * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a previously planned trajectory. Enables the caller to attach input/output actions to the trajectory.  Understanding the concept of location:   The location or path parameter specifies the exact position along a trajectory.   The location is a scalar value that ranges from 0 to `n`,   where `n` denotes the number of motion commands, or trajectory segments, e.g. line, p2p, etc. See [planMotion](planMotion).   Each integer value of the location corresponds to one motion command, e.g. 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with InitializeMovementRequest. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send InitializeMovementRequest to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send StartMovementRequest to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send PauseMovementRequest before the movement has reached its end location. - Change the movement\'s velocity with PlaybackSpeedRequest after initializing the movement with InitializeMovementRequest.  ### Responses  - InitializeMovementResponse is sent to signal the success or failure of the InitializeMovementRequest. - Movement responses are streamed after a StartMovementRequest successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by InitializeMovementRequest. - Standstill reponse  is sent once the movement has finished or has come to a standstill due to a pause. - PauseMovementResponse is sent to signal the success of the PauseMovementRequest. It does not signal the end of the movement.   End of movement is signaled by Standstill reponse . - PlaybackSpeedResponse is sent to signal the success of the PlaybackSpeedRequest. - MovementError with error details is sent in case of an unexpected error, e.g. controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending PauseMovementRequest and StartMovementRequest. - Send PlaybackSpeedRequest before StartMovementRequest to reduce the velocity of the movement before it starts. - Send PlaybackSpeedRequest repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send PlaybackSpeedRequest with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending StartMovementRequest after the movement has finished.
-         * @summary Execute Trajectory
+         * Get a previously created trajectory from cache. Use [listTrajectories](listTrajectories) to list all cached trajectories.
+         * @summary Get Trajectory
          * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {ExecuteTrajectoryRequest} executeTrajectoryRequest
+         * @param {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        executeTrajectory: async (cell, executeTrajectoryRequest, options = {}) => {
+        getTrajectory: async (cell, trajectory, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('executeTrajectory', 'cell', cell);
-            // verify required parameter 'executeTrajectoryRequest' is not null or undefined
-            assertParamExists('executeTrajectory', 'executeTrajectoryRequest', executeTrajectoryRequest);
-            const localVarPath = `/cells/{cell}/execution/trajectory`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
+            assertParamExists('getTrajectory', 'cell', cell);
+            // verify required parameter 'trajectory' is not null or undefined
+            assertParamExists('getTrajectory', 'trajectory', trajectory);
+            const localVarPath = `/cells/{cell}/trajectories/{trajectory}`
+                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
+                .replace(`{${"trajectory"}}`, encodeURIComponent(String(trajectory)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -10188,11 +8172,9 @@ export const TrajectoryExecutionApiAxiosParamCreator = function (configuration)
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            localVarHeaderParameter['Content-Type'] = 'application/json';
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            localVarRequestOptions.data = serializeDataIfNeeded(executeTrajectoryRequest, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
@@ -10236,14 +8218,14 @@ export const TrajectoryExecutionApiAxiosParamCreator = function (configuration)
     };
 };
 /**
- * TrajectoryExecutionApi - functional programming interface
+ * TrajectoryCachingApi - functional programming interface
  * @export
  */
-export const TrajectoryExecutionApiFp = function (configuration) {
-    const localVarAxiosParamCreator = TrajectoryExecutionApiAxiosParamCreator(configuration);
+export const TrajectoryCachingApiFp = function (configuration) {
+    const localVarAxiosParamCreator = TrajectoryCachingApiAxiosParamCreator(configuration);
     return {
         /**
-         * Loads and validates the data of a trajectory into the execution cache, rendering the trajectory executable. The response contains the result of the validation of the trajectory.  Validation can lead to three different results: - Fully valid: The whole trajectory can be executed from start to end. The response will contain an unique identifier which is used to move the robot. - Partially valid: Only parts of the trajectory can be executed. The response will contain an unique identifier to move the robot   and information about the failure for the part that is not executable. - Invalid: The trajectory can not be executed. The response will tell you the reason of failure.  If the trajectory is at least partially valid, the parts of the trajectory that are valid can be executed using the [executeTrajectory](executeTrajectory) endpoint.  The workflow is as follows:   - Generate a trajectory with [planTrajectory](planTrajectory) or your own motion planner,   - Send the trajectory to this endpoint to validate it and get a unique identifier for it,   - The unique identifier will appear in the list of available trajectories, see [listTrajectories](listTrajectories) endpoint, if it is at least partially executable.   - Move motion group to trajectory using the [executeToTrajectory](executeToTrajectory) endpoint.   - Execute your trajectory using the [executeTrajectory](executeTrajectory) endpoint.
+         * <!-- theme: info -->  > Using the trajectory cache is an optional performance optimization. It is not necessary to use the cache to execute trajectories.  Loads and validates the data of a trajectory into the execution cache, rendering the trajectory executable. The response contains the result of the validation of the trajectory.  Validation can lead to three different results: - Fully valid: The whole trajectory can be executed from start to end. The response will contain an unique identifier which is used to move the robot. - Partially valid: Only parts of the trajectory can be executed. The response will contain an unique identifier to move the robot   and information about the failure for the part that is not executable. - Invalid: The trajectory can not be executed. The response will tell you the reason of failure.  If the trajectory is at least partially valid, the parts of the trajectory that are valid can be executed using the [executeTrajectory](executeTrajectory) endpoint.  The workflow is as follows:   - Generate a trajectory with [planTrajectory](planTrajectory) or your own motion planner,   - Send the trajectory to this endpoint to validate it and get a unique identifier for it,   - The unique identifier will appear in the list of available trajectories, see [listTrajectories](listTrajectories) endpoint, if it is at least partially executable.   - Execute your trajectory using the [executeTrajectory](executeTrajectory) endpoint.
          * @summary Add Trajectory
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {AddTrajectoryRequest} addTrajectoryRequest
@@ -10253,7 +8235,7 @@ export const TrajectoryExecutionApiFp = function (configuration) {
         async addTrajectory(cell, addTrajectoryRequest, options) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.addTrajectory(cell, addTrajectoryRequest, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['TrajectoryExecutionApi.addTrajectory']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['TrajectoryCachingApi.addTrajectory']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -10266,7 +8248,7 @@ export const TrajectoryExecutionApiFp = function (configuration) {
         async clearTrajectories(cell, options) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.clearTrajectories(cell, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['TrajectoryExecutionApi.clearTrajectories']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['TrajectoryCachingApi.clearTrajectories']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -10280,43 +8262,21 @@ export const TrajectoryExecutionApiFp = function (configuration) {
         async deleteTrajectory(cell, trajectory, options) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.deleteTrajectory(cell, trajectory, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['TrajectoryExecutionApi.deleteTrajectory']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['TrajectoryCachingApi.deleteTrajectory']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Request to move the motion group via joint point-to-point to a given location on a trajectory.  To start moving along a trajectory from an arbitrary location, the current joint positions must match the joint positions of the trajectory at the given location.  > **Note:** To abort the movement, the connection needs to be closed.
-         * @summary Move to Trajectory
+         * Get a previously created trajectory from cache. Use [listTrajectories](listTrajectories) to list all cached trajectories.
+         * @summary Get Trajectory
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory.
-         * @param {number} locationOnTrajectory
-         * @param {Array<number>} [overrideJointVelocityLimits] The joint velocity limits for the p2p movement to a previously added trajectory.
-         * @param {Array<number>} [overrideJointAccelerationLimits] The joint acceleration limits for the p2p movement to a previously added trajectory.
-         * @param {number} [overrideTcpVelocityLimit] Maximum allowed TCP velocity in [mm/s].
-         * @param {number} [overrideTcpAccelerationLimit] Maximum allowed TCP acceleration in [mm/s^2].
-         * @param {number} [overrideTcpOrientationVelocityLimit] Maximum allowed TCP rotation velocity in [rad/s].
-         * @param {number} [overrideTcpOrientationAccelerationLimit] Maximum allowed TCP rotation acceleration in [rad/s^2].
-         * @param {string} [responsesCoordinateSystem]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async executeToTrajectory(cell, trajectory, locationOnTrajectory, overrideJointVelocityLimits, overrideJointAccelerationLimits, overrideTcpVelocityLimit, overrideTcpAccelerationLimit, overrideTcpOrientationVelocityLimit, overrideTcpOrientationAccelerationLimit, responsesCoordinateSystem, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.executeToTrajectory(cell, trajectory, locationOnTrajectory, overrideJointVelocityLimits, overrideJointAccelerationLimits, overrideTcpVelocityLimit, overrideTcpAccelerationLimit, overrideTcpOrientationVelocityLimit, overrideTcpOrientationAccelerationLimit, responsesCoordinateSystem, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['TrajectoryExecutionApi.executeToTrajectory']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        /**
-         * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a previously planned trajectory. Enables the caller to attach input/output actions to the trajectory.  Understanding the concept of location:   The location or path parameter specifies the exact position along a trajectory.   The location is a scalar value that ranges from 0 to `n`,   where `n` denotes the number of motion commands, or trajectory segments, e.g. line, p2p, etc. See [planMotion](planMotion).   Each integer value of the location corresponds to one motion command, e.g. 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with InitializeMovementRequest. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send InitializeMovementRequest to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send StartMovementRequest to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send PauseMovementRequest before the movement has reached its end location. - Change the movement\'s velocity with PlaybackSpeedRequest after initializing the movement with InitializeMovementRequest.  ### Responses  - InitializeMovementResponse is sent to signal the success or failure of the InitializeMovementRequest. - Movement responses are streamed after a StartMovementRequest successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by InitializeMovementRequest. - Standstill reponse  is sent once the movement has finished or has come to a standstill due to a pause. - PauseMovementResponse is sent to signal the success of the PauseMovementRequest. It does not signal the end of the movement.   End of movement is signaled by Standstill reponse . - PlaybackSpeedResponse is sent to signal the success of the PlaybackSpeedRequest. - MovementError with error details is sent in case of an unexpected error, e.g. controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending PauseMovementRequest and StartMovementRequest. - Send PlaybackSpeedRequest before StartMovementRequest to reduce the velocity of the movement before it starts. - Send PlaybackSpeedRequest repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send PlaybackSpeedRequest with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending StartMovementRequest after the movement has finished.
-         * @summary Execute Trajectory
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {ExecuteTrajectoryRequest} executeTrajectoryRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async executeTrajectory(cell, executeTrajectoryRequest, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.executeTrajectory(cell, executeTrajectoryRequest, options);
+        async getTrajectory(cell, trajectory, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getTrajectory(cell, trajectory, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['TrajectoryExecutionApi.executeTrajectory']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['TrajectoryCachingApi.getTrajectory']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -10329,20 +8289,20 @@ export const TrajectoryExecutionApiFp = function (configuration) {
         async listTrajectories(cell, options) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.listTrajectories(cell, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['TrajectoryExecutionApi.listTrajectories']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['TrajectoryCachingApi.listTrajectories']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     };
 };
 /**
- * TrajectoryExecutionApi - factory interface
+ * TrajectoryCachingApi - factory interface
  * @export
  */
-export const TrajectoryExecutionApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = TrajectoryExecutionApiFp(configuration);
+export const TrajectoryCachingApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = TrajectoryCachingApiFp(configuration);
     return {
         /**
-         * Loads and validates the data of a trajectory into the execution cache, rendering the trajectory executable. The response contains the result of the validation of the trajectory.  Validation can lead to three different results: - Fully valid: The whole trajectory can be executed from start to end. The response will contain an unique identifier which is used to move the robot. - Partially valid: Only parts of the trajectory can be executed. The response will contain an unique identifier to move the robot   and information about the failure for the part that is not executable. - Invalid: The trajectory can not be executed. The response will tell you the reason of failure.  If the trajectory is at least partially valid, the parts of the trajectory that are valid can be executed using the [executeTrajectory](executeTrajectory) endpoint.  The workflow is as follows:   - Generate a trajectory with [planTrajectory](planTrajectory) or your own motion planner,   - Send the trajectory to this endpoint to validate it and get a unique identifier for it,   - The unique identifier will appear in the list of available trajectories, see [listTrajectories](listTrajectories) endpoint, if it is at least partially executable.   - Move motion group to trajectory using the [executeToTrajectory](executeToTrajectory) endpoint.   - Execute your trajectory using the [executeTrajectory](executeTrajectory) endpoint.
+         * <!-- theme: info -->  > Using the trajectory cache is an optional performance optimization. It is not necessary to use the cache to execute trajectories.  Loads and validates the data of a trajectory into the execution cache, rendering the trajectory executable. The response contains the result of the validation of the trajectory.  Validation can lead to three different results: - Fully valid: The whole trajectory can be executed from start to end. The response will contain an unique identifier which is used to move the robot. - Partially valid: Only parts of the trajectory can be executed. The response will contain an unique identifier to move the robot   and information about the failure for the part that is not executable. - Invalid: The trajectory can not be executed. The response will tell you the reason of failure.  If the trajectory is at least partially valid, the parts of the trajectory that are valid can be executed using the [executeTrajectory](executeTrajectory) endpoint.  The workflow is as follows:   - Generate a trajectory with [planTrajectory](planTrajectory) or your own motion planner,   - Send the trajectory to this endpoint to validate it and get a unique identifier for it,   - The unique identifier will appear in the list of available trajectories, see [listTrajectories](listTrajectories) endpoint, if it is at least partially executable.   - Execute your trajectory using the [executeTrajectory](executeTrajectory) endpoint.
          * @summary Add Trajectory
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {AddTrajectoryRequest} addTrajectoryRequest
@@ -10374,34 +8334,15 @@ export const TrajectoryExecutionApiFactory = function (configuration, basePath,
             return localVarFp.deleteTrajectory(cell, trajectory, options).then((request) => request(axios, basePath));
         },
         /**
-         * Request to move the motion group via joint point-to-point to a given location on a trajectory.  To start moving along a trajectory from an arbitrary location, the current joint positions must match the joint positions of the trajectory at the given location.  > **Note:** To abort the movement, the connection needs to be closed.
-         * @summary Move to Trajectory
+         * Get a previously created trajectory from cache. Use [listTrajectories](listTrajectories) to list all cached trajectories.
+         * @summary Get Trajectory
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory.
-         * @param {number} locationOnTrajectory
-         * @param {Array<number>} [overrideJointVelocityLimits] The joint velocity limits for the p2p movement to a previously added trajectory.
-         * @param {Array<number>} [overrideJointAccelerationLimits] The joint acceleration limits for the p2p movement to a previously added trajectory.
-         * @param {number} [overrideTcpVelocityLimit] Maximum allowed TCP velocity in [mm/s].
-         * @param {number} [overrideTcpAccelerationLimit] Maximum allowed TCP acceleration in [mm/s^2].
-         * @param {number} [overrideTcpOrientationVelocityLimit] Maximum allowed TCP rotation velocity in [rad/s].
-         * @param {number} [overrideTcpOrientationAccelerationLimit] Maximum allowed TCP rotation acceleration in [rad/s^2].
-         * @param {string} [responsesCoordinateSystem]
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        executeToTrajectory(cell, trajectory, locationOnTrajectory, overrideJointVelocityLimits, overrideJointAccelerationLimits, overrideTcpVelocityLimit, overrideTcpAccelerationLimit, overrideTcpOrientationVelocityLimit, overrideTcpOrientationAccelerationLimit, responsesCoordinateSystem, options) {
-            return localVarFp.executeToTrajectory(cell, trajectory, locationOnTrajectory, overrideJointVelocityLimits, overrideJointAccelerationLimits, overrideTcpVelocityLimit, overrideTcpAccelerationLimit, overrideTcpOrientationVelocityLimit, overrideTcpOrientationAccelerationLimit, responsesCoordinateSystem, options).then((request) => request(axios, basePath));
-        },
-        /**
-         * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a previously planned trajectory. Enables the caller to attach input/output actions to the trajectory.  Understanding the concept of location:   The location or path parameter specifies the exact position along a trajectory.   The location is a scalar value that ranges from 0 to `n`,   where `n` denotes the number of motion commands, or trajectory segments, e.g. line, p2p, etc. See [planMotion](planMotion).   Each integer value of the location corresponds to one motion command, e.g. 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with InitializeMovementRequest. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send InitializeMovementRequest to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send StartMovementRequest to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send PauseMovementRequest before the movement has reached its end location. - Change the movement\'s velocity with PlaybackSpeedRequest after initializing the movement with InitializeMovementRequest.  ### Responses  - InitializeMovementResponse is sent to signal the success or failure of the InitializeMovementRequest. - Movement responses are streamed after a StartMovementRequest successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by InitializeMovementRequest. - Standstill reponse  is sent once the movement has finished or has come to a standstill due to a pause. - PauseMovementResponse is sent to signal the success of the PauseMovementRequest. It does not signal the end of the movement.   End of movement is signaled by Standstill reponse . - PlaybackSpeedResponse is sent to signal the success of the PlaybackSpeedRequest. - MovementError with error details is sent in case of an unexpected error, e.g. controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending PauseMovementRequest and StartMovementRequest. - Send PlaybackSpeedRequest before StartMovementRequest to reduce the velocity of the movement before it starts. - Send PlaybackSpeedRequest repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send PlaybackSpeedRequest with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending StartMovementRequest after the movement has finished.
-         * @summary Execute Trajectory
-         * @param {string} cell Unique identifier addressing a cell in all API calls.
-         * @param {ExecuteTrajectoryRequest} executeTrajectoryRequest
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        executeTrajectory(cell, executeTrajectoryRequest, options) {
-            return localVarFp.executeTrajectory(cell, executeTrajectoryRequest, options).then((request) => request(axios, basePath));
+        getTrajectory(cell, trajectory, options) {
+            return localVarFp.getTrajectory(cell, trajectory, options).then((request) => request(axios, basePath));
         },
         /**
          * List currently cached trajectories. Use [addTrajectory](addTrajectory) to add a new trajectory. Adding trajectories is necessary to execute them. Trajectories are removed if the corresponding motion group or controller disconnects.
@@ -10416,23 +8357,23 @@ export const TrajectoryExecutionApiFactory = function (configuration, basePath,
     };
 };
 /**
- * TrajectoryExecutionApi - object-oriented interface
+ * TrajectoryCachingApi - object-oriented interface
  * @export
- * @class TrajectoryExecutionApi
+ * @class TrajectoryCachingApi
  * @extends {BaseAPI}
  */
-export class TrajectoryExecutionApi extends BaseAPI {
+export class TrajectoryCachingApi extends BaseAPI {
     /**
-     * Loads and validates the data of a trajectory into the execution cache, rendering the trajectory executable. The response contains the result of the validation of the trajectory.  Validation can lead to three different results: - Fully valid: The whole trajectory can be executed from start to end. The response will contain an unique identifier which is used to move the robot. - Partially valid: Only parts of the trajectory can be executed. The response will contain an unique identifier to move the robot   and information about the failure for the part that is not executable. - Invalid: The trajectory can not be executed. The response will tell you the reason of failure.  If the trajectory is at least partially valid, the parts of the trajectory that are valid can be executed using the [executeTrajectory](executeTrajectory) endpoint.  The workflow is as follows:   - Generate a trajectory with [planTrajectory](planTrajectory) or your own motion planner,   - Send the trajectory to this endpoint to validate it and get a unique identifier for it,   - The unique identifier will appear in the list of available trajectories, see [listTrajectories](listTrajectories) endpoint, if it is at least partially executable.   - Move motion group to trajectory using the [executeToTrajectory](executeToTrajectory) endpoint.   - Execute your trajectory using the [executeTrajectory](executeTrajectory) endpoint.
+     * <!-- theme: info -->  > Using the trajectory cache is an optional performance optimization. It is not necessary to use the cache to execute trajectories.  Loads and validates the data of a trajectory into the execution cache, rendering the trajectory executable. The response contains the result of the validation of the trajectory.  Validation can lead to three different results: - Fully valid: The whole trajectory can be executed from start to end. The response will contain an unique identifier which is used to move the robot. - Partially valid: Only parts of the trajectory can be executed. The response will contain an unique identifier to move the robot   and information about the failure for the part that is not executable. - Invalid: The trajectory can not be executed. The response will tell you the reason of failure.  If the trajectory is at least partially valid, the parts of the trajectory that are valid can be executed using the [executeTrajectory](executeTrajectory) endpoint.  The workflow is as follows:   - Generate a trajectory with [planTrajectory](planTrajectory) or your own motion planner,   - Send the trajectory to this endpoint to validate it and get a unique identifier for it,   - The unique identifier will appear in the list of available trajectories, see [listTrajectories](listTrajectories) endpoint, if it is at least partially executable.   - Execute your trajectory using the [executeTrajectory](executeTrajectory) endpoint.
      * @summary Add Trajectory
      * @param {string} cell Unique identifier addressing a cell in all API calls.
      * @param {AddTrajectoryRequest} addTrajectoryRequest
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof TrajectoryExecutionApi
+     * @memberof TrajectoryCachingApi
      */
     addTrajectory(cell, addTrajectoryRequest, options) {
-        return TrajectoryExecutionApiFp(this.configuration).addTrajectory(cell, addTrajectoryRequest, options).then((request) => request(this.axios, this.basePath));
+        return TrajectoryCachingApiFp(this.configuration).addTrajectory(cell, addTrajectoryRequest, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * Clear the trajectory cache.
@@ -10440,10 +8381,10 @@ export class TrajectoryExecutionApi extends BaseAPI {
      * @param {string} cell Unique identifier addressing a cell in all API calls.
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof TrajectoryExecutionApi
+     * @memberof TrajectoryCachingApi
      */
     clearTrajectories(cell, options) {
-        return TrajectoryExecutionApiFp(this.configuration).clearTrajectories(cell, options).then((request) => request(this.axios, this.basePath));
+        return TrajectoryCachingApiFp(this.configuration).clearTrajectories(cell, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * Delete a previously created trajectory from cache. Use [listTrajectories](listTrajectories) to list all cached trajectories. Trajectories are removed automatically if the motion group or the corresponding controller is disconnected.
@@ -10452,53 +8393,144 @@ export class TrajectoryExecutionApi extends BaseAPI {
      * @param {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory.
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof TrajectoryExecutionApi
+     * @memberof TrajectoryCachingApi
      */
     deleteTrajectory(cell, trajectory, options) {
-        return TrajectoryExecutionApiFp(this.configuration).deleteTrajectory(cell, trajectory, options).then((request) => request(this.axios, this.basePath));
+        return TrajectoryCachingApiFp(this.configuration).deleteTrajectory(cell, trajectory, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Request to move the motion group via joint point-to-point to a given location on a trajectory.  To start moving along a trajectory from an arbitrary location, the current joint positions must match the joint positions of the trajectory at the given location.  > **Note:** To abort the movement, the connection needs to be closed.
-     * @summary Move to Trajectory
+     * Get a previously created trajectory from cache. Use [listTrajectories](listTrajectories) to list all cached trajectories.
+     * @summary Get Trajectory
      * @param {string} cell Unique identifier addressing a cell in all API calls.
      * @param {string} trajectory This represents the unique identifier of a trajectory. Every executable or partially executable trajectory is cached and an unique identifier is returned. Indicate the unique identifier to execute the trajectory or retrieve information on the trajectory.
-     * @param {number} locationOnTrajectory
-     * @param {Array<number>} [overrideJointVelocityLimits] The joint velocity limits for the p2p movement to a previously added trajectory.
-     * @param {Array<number>} [overrideJointAccelerationLimits] The joint acceleration limits for the p2p movement to a previously added trajectory.
-     * @param {number} [overrideTcpVelocityLimit] Maximum allowed TCP velocity in [mm/s].
-     * @param {number} [overrideTcpAccelerationLimit] Maximum allowed TCP acceleration in [mm/s^2].
-     * @param {number} [overrideTcpOrientationVelocityLimit] Maximum allowed TCP rotation velocity in [rad/s].
-     * @param {number} [overrideTcpOrientationAccelerationLimit] Maximum allowed TCP rotation acceleration in [rad/s^2].
-     * @param {string} [responsesCoordinateSystem]
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof TrajectoryExecutionApi
+     * @memberof TrajectoryCachingApi
      */
-    executeToTrajectory(cell, trajectory, locationOnTrajectory, overrideJointVelocityLimits, overrideJointAccelerationLimits, overrideTcpVelocityLimit, overrideTcpAccelerationLimit, overrideTcpOrientationVelocityLimit, overrideTcpOrientationAccelerationLimit, responsesCoordinateSystem, options) {
-        return TrajectoryExecutionApiFp(this.configuration).executeToTrajectory(cell, trajectory, locationOnTrajectory, overrideJointVelocityLimits, overrideJointAccelerationLimits, overrideTcpVelocityLimit, overrideTcpAccelerationLimit, overrideTcpOrientationVelocityLimit, overrideTcpOrientationAccelerationLimit, responsesCoordinateSystem, options).then((request) => request(this.axios, this.basePath));
+    getTrajectory(cell, trajectory, options) {
+        return TrajectoryCachingApiFp(this.configuration).getTrajectory(cell, trajectory, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a previously planned trajectory. Enables the caller to attach input/output actions to the trajectory.  Understanding the concept of location:   The location or path parameter specifies the exact position along a trajectory.   The location is a scalar value that ranges from 0 to `n`,   where `n` denotes the number of motion commands, or trajectory segments, e.g. line, p2p, etc. See [planMotion](planMotion).   Each integer value of the location corresponds to one motion command, e.g. 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with InitializeMovementRequest. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send InitializeMovementRequest to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send StartMovementRequest to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send PauseMovementRequest before the movement has reached its end location. - Change the movement\'s velocity with PlaybackSpeedRequest after initializing the movement with InitializeMovementRequest.  ### Responses  - InitializeMovementResponse is sent to signal the success or failure of the InitializeMovementRequest. - Movement responses are streamed after a StartMovementRequest successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by InitializeMovementRequest. - Standstill reponse  is sent once the movement has finished or has come to a standstill due to a pause. - PauseMovementResponse is sent to signal the success of the PauseMovementRequest. It does not signal the end of the movement.   End of movement is signaled by Standstill reponse . - PlaybackSpeedResponse is sent to signal the success of the PlaybackSpeedRequest. - MovementError with error details is sent in case of an unexpected error, e.g. controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending PauseMovementRequest and StartMovementRequest. - Send PlaybackSpeedRequest before StartMovementRequest to reduce the velocity of the movement before it starts. - Send PlaybackSpeedRequest repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send PlaybackSpeedRequest with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending StartMovementRequest after the movement has finished.
-     * @summary Execute Trajectory
+     * List currently cached trajectories. Use [addTrajectory](addTrajectory) to add a new trajectory. Adding trajectories is necessary to execute them. Trajectories are removed if the corresponding motion group or controller disconnects.
+     * @summary List Trajectories
      * @param {string} cell Unique identifier addressing a cell in all API calls.
-     * @param {ExecuteTrajectoryRequest} executeTrajectoryRequest
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof TrajectoryExecutionApi
+     * @memberof TrajectoryCachingApi
      */
-    executeTrajectory(cell, executeTrajectoryRequest, options) {
-        return TrajectoryExecutionApiFp(this.configuration).executeTrajectory(cell, executeTrajectoryRequest, options).then((request) => request(this.axios, this.basePath));
+    listTrajectories(cell, options) {
+        return TrajectoryCachingApiFp(this.configuration).listTrajectories(cell, options).then((request) => request(this.axios, this.basePath));
     }
+}
+/**
+ * TrajectoryExecutionApi - axios parameter creator
+ * @export
+ */
+export const TrajectoryExecutionApiAxiosParamCreator = function (configuration) {
+    return {
+        /**
+         * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a previously planned trajectory. Enables the caller to attach input/output actions to the trajectory.  Understanding the concept of location:   The location or path parameter specifies the exact position along a trajectory.   The location is a scalar value that ranges from 0 to `n`,   where `n` denotes the number of motion commands, or trajectory segments, e.g. line, p2p, etc. See [planMotion](planMotion).   Each integer value of the location corresponds to one motion command, e.g. 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with InitializeMovementRequest. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send InitializeMovementRequest to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send StartMovementRequest to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send PauseMovementRequest before the movement has reached its end location. - Change the movement\'s velocity with PlaybackSpeedRequest after initializing the movement with InitializeMovementRequest.  ### Responses  - InitializeMovementResponse is sent to signal the success or failure of the InitializeMovementRequest. - Movement responses are streamed after a StartMovementRequest successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by InitializeMovementRequest. - Standstill reponse  is sent once the movement has finished or has come to a standstill due to a pause. - PauseMovementResponse is sent to signal the success of the PauseMovementRequest. It does not signal the end of the movement.   End of movement is signaled by Standstill reponse . - PlaybackSpeedResponse is sent to signal the success of the PlaybackSpeedRequest. - MovementError with error details is sent in case of an unexpected error, e.g. controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending PauseMovementRequest and StartMovementRequest. - Send PlaybackSpeedRequest before StartMovementRequest to reduce the velocity of the movement before it starts. - Send PlaybackSpeedRequest repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send PlaybackSpeedRequest with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending StartMovementRequest after the movement has finished.
+         * @summary Execute Trajectory
+         * @param {string} cell Unique identifier addressing a cell in all API calls.
+         * @param {ExecuteTrajectoryRequest} executeTrajectoryRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        executeTrajectory: async (cell, executeTrajectoryRequest, options = {}) => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('executeTrajectory', 'cell', cell);
+            // verify required parameter 'executeTrajectoryRequest' is not null or undefined
+            assertParamExists('executeTrajectory', 'executeTrajectoryRequest', executeTrajectoryRequest);
+            const localVarPath = `/cells/{cell}/execution/trajectory`
+                .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;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication BasicAuth required
+            // http basic authentication required
+            setBasicAuthToObject(localVarRequestOptions, configuration);
+            // authentication BearerAuth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(executeTrajectoryRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    };
+};
+/**
+ * TrajectoryExecutionApi - functional programming interface
+ * @export
+ */
+export const TrajectoryExecutionApiFp = function (configuration) {
+    const localVarAxiosParamCreator = TrajectoryExecutionApiAxiosParamCreator(configuration);
+    return {
+        /**
+         * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a previously planned trajectory. Enables the caller to attach input/output actions to the trajectory.  Understanding the concept of location:   The location or path parameter specifies the exact position along a trajectory.   The location is a scalar value that ranges from 0 to `n`,   where `n` denotes the number of motion commands, or trajectory segments, e.g. line, p2p, etc. See [planMotion](planMotion).   Each integer value of the location corresponds to one motion command, e.g. 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with InitializeMovementRequest. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send InitializeMovementRequest to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send StartMovementRequest to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send PauseMovementRequest before the movement has reached its end location. - Change the movement\'s velocity with PlaybackSpeedRequest after initializing the movement with InitializeMovementRequest.  ### Responses  - InitializeMovementResponse is sent to signal the success or failure of the InitializeMovementRequest. - Movement responses are streamed after a StartMovementRequest successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by InitializeMovementRequest. - Standstill reponse  is sent once the movement has finished or has come to a standstill due to a pause. - PauseMovementResponse is sent to signal the success of the PauseMovementRequest. It does not signal the end of the movement.   End of movement is signaled by Standstill reponse . - PlaybackSpeedResponse is sent to signal the success of the PlaybackSpeedRequest. - MovementError with error details is sent in case of an unexpected error, e.g. controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending PauseMovementRequest and StartMovementRequest. - Send PlaybackSpeedRequest before StartMovementRequest to reduce the velocity of the movement before it starts. - Send PlaybackSpeedRequest repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send PlaybackSpeedRequest with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending StartMovementRequest after the movement has finished.
+         * @summary Execute Trajectory
+         * @param {string} cell Unique identifier addressing a cell in all API calls.
+         * @param {ExecuteTrajectoryRequest} executeTrajectoryRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async executeTrajectory(cell, executeTrajectoryRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.executeTrajectory(cell, executeTrajectoryRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['TrajectoryExecutionApi.executeTrajectory']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    };
+};
+/**
+ * TrajectoryExecutionApi - factory interface
+ * @export
+ */
+export const TrajectoryExecutionApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = TrajectoryExecutionApiFp(configuration);
+    return {
+        /**
+         * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a previously planned trajectory. Enables the caller to attach input/output actions to the trajectory.  Understanding the concept of location:   The location or path parameter specifies the exact position along a trajectory.   The location is a scalar value that ranges from 0 to `n`,   where `n` denotes the number of motion commands, or trajectory segments, e.g. line, p2p, etc. See [planMotion](planMotion).   Each integer value of the location corresponds to one motion command, e.g. 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with InitializeMovementRequest. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send InitializeMovementRequest to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send StartMovementRequest to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send PauseMovementRequest before the movement has reached its end location. - Change the movement\'s velocity with PlaybackSpeedRequest after initializing the movement with InitializeMovementRequest.  ### Responses  - InitializeMovementResponse is sent to signal the success or failure of the InitializeMovementRequest. - Movement responses are streamed after a StartMovementRequest successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by InitializeMovementRequest. - Standstill reponse  is sent once the movement has finished or has come to a standstill due to a pause. - PauseMovementResponse is sent to signal the success of the PauseMovementRequest. It does not signal the end of the movement.   End of movement is signaled by Standstill reponse . - PlaybackSpeedResponse is sent to signal the success of the PlaybackSpeedRequest. - MovementError with error details is sent in case of an unexpected error, e.g. controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending PauseMovementRequest and StartMovementRequest. - Send PlaybackSpeedRequest before StartMovementRequest to reduce the velocity of the movement before it starts. - Send PlaybackSpeedRequest repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send PlaybackSpeedRequest with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending StartMovementRequest after the movement has finished.
+         * @summary Execute Trajectory
+         * @param {string} cell Unique identifier addressing a cell in all API calls.
+         * @param {ExecuteTrajectoryRequest} executeTrajectoryRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        executeTrajectory(cell, executeTrajectoryRequest, options) {
+            return localVarFp.executeTrajectory(cell, executeTrajectoryRequest, options).then((request) => request(axios, basePath));
+        },
+    };
+};
+/**
+ * TrajectoryExecutionApi - object-oriented interface
+ * @export
+ * @class TrajectoryExecutionApi
+ * @extends {BaseAPI}
+ */
+export class TrajectoryExecutionApi extends BaseAPI {
     /**
-     * List currently cached trajectories. Use [addTrajectory](addTrajectory) to add a new trajectory. Adding trajectories is necessary to execute them. Trajectories are removed if the corresponding motion group or controller disconnects.
-     * @summary List Trajectories
+     * <!-- theme: danger -->  > Websocket endpoint  Provides execution control over a previously planned trajectory. Enables the caller to attach input/output actions to the trajectory.  Understanding the concept of location:   The location or path parameter specifies the exact position along a trajectory.   The location is a scalar value that ranges from 0 to `n`,   where `n` denotes the number of motion commands, or trajectory segments, e.g. line, p2p, etc. See [planMotion](planMotion).   Each integer value of the location corresponds to one motion command, e.g. 3.0 to 3.999 could be a line.  ### Preconditions  - The motion group\'s control mode is not claimed by any other endpoint. - The motion group\'s joint position are at start location specified with InitializeMovementRequest. - Use [executeToTrajectory](executeToTrajectory) to move the robot to the start location.  ### Requests  #### 1. Send InitializeMovementRequest to lock the trajectory to this connection   The following actions are executed:   - Sets robot controller mode to control mode,   - Sets start location of the execution    Keep in mind that only a single trajectory can be locked to a websocket connection at a time and not unlocked anymore.   To execute another trajectory, a new connection must be established.  #### 2. Send StartMovementRequest to start the movement  Sets direction of movement, default is forward.  #### **Optional**  - To pause, send PauseMovementRequest before the movement has reached its end location. - Change the movement\'s velocity with PlaybackSpeedRequest after initializing the movement with InitializeMovementRequest.  ### Responses  - InitializeMovementResponse is sent to signal the success or failure of the InitializeMovementRequest. - Movement responses are streamed after a StartMovementRequest successfully started the movement.   Movement responses are streamed in a rate that is defined as the multiple of the controller step-rate closest to   but not exceeding the rate configured by InitializeMovementRequest. - Standstill reponse  is sent once the movement has finished or has come to a standstill due to a pause. - PauseMovementResponse is sent to signal the success of the PauseMovementRequest. It does not signal the end of the movement.   End of movement is signaled by Standstill reponse . - PlaybackSpeedResponse is sent to signal the success of the PlaybackSpeedRequest. - MovementError with error details is sent in case of an unexpected error, e.g. controller disconnects during movement.  ### Tips and Tricks  - A movement can be paused and resumed by sending PauseMovementRequest and StartMovementRequest. - Send PlaybackSpeedRequest before StartMovementRequest to reduce the velocity of the movement before it starts. - Send PlaybackSpeedRequest repeatedly to implement a slider. The velocity of the motion group can be adjusted with each controller step. Therefore, if your app needs a slider-like UI to alter the velocity of a currently running movement, you can send PlaybackSpeedRequest with different speed values repeatedly during the movement. - A closed trajectory (end and start joint position are equal) can be repeated by sending StartMovementRequest after the movement has finished.
+     * @summary Execute Trajectory
      * @param {string} cell Unique identifier addressing a cell in all API calls.
+     * @param {ExecuteTrajectoryRequest} executeTrajectoryRequest
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof TrajectoryExecutionApi
      */
-    listTrajectories(cell, options) {
-        return TrajectoryExecutionApiFp(this.configuration).listTrajectories(cell, options).then((request) => request(this.axios, this.basePath));
+    executeTrajectory(cell, executeTrajectoryRequest, options) {
+        return TrajectoryExecutionApiFp(this.configuration).executeTrajectory(cell, executeTrajectoryRequest, options).then((request) => request(this.axios, this.basePath));
     }
 }
 /**
@@ -10507,6 +8539,45 @@ export class TrajectoryExecutionApi extends BaseAPI {
  */
 export const TrajectoryPlanningApiAxiosParamCreator = function (configuration) {
     return {
+        /**
+         * Returns the default collision link chain for a given motion group model.  See [getPlanningMotionGroupModels](getPlanningMotionGroupModels) for supported motion group models.  The default link chain is derived from 3D models and optimized for collision detection within NOVA.  The default link chain includes link shapes only. It does not include any attached components like wire feeders or sensors.  Use the `stored_link_chain` or `link_chain` field in [storeCollisionScene](storeCollisionScene) to attach additional shapes to the link reference frames. Additional shapes may overlap each other per link and may also overlap the respective link\'s default shape.
+         * @summary Get Default Link Chain
+         * @param {string} cell Unique identifier addressing a cell in all API calls.
+         * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g. &#x60;UniversalRobots_UR10e&#x60;.  Get the &#x60;model&#x60; of a configured motion group with [getOptimizerConfiguration](getOptimizerConfiguration).
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getDefaultLinkChain: async (cell, motionGroupModel, options = {}) => {
+            // verify required parameter 'cell' is not null or undefined
+            assertParamExists('getDefaultLinkChain', 'cell', cell);
+            // verify required parameter 'motionGroupModel' is not null or undefined
+            assertParamExists('getDefaultLinkChain', 'motionGroupModel', motionGroupModel);
+            const localVarPath = `/cells/{cell}/store/collision/default-link-chains/{motion-group-model}`
+                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
+                .replace(`{${"motion-group-model"}}`, encodeURIComponent(String(motionGroupModel)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication BasicAuth required
+            // http basic authentication required
+            setBasicAuthToObject(localVarRequestOptions, configuration);
+            // authentication BearerAuth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * Returns motion group models that are supported for planning.
          * @summary Motion Group Models for Planning
@@ -10514,9 +8585,9 @@ export const TrajectoryPlanningApiAxiosParamCreator = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getPlanningMotionGroupModels: async (cell, options = {}) => {
+        getMotionGroupModelsForPlanning: async (cell, options = {}) => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getPlanningMotionGroupModels', 'cell', cell);
+            assertParamExists('getMotionGroupModelsForPlanning', 'cell', cell);
             const localVarPath = `/cells/{cell}/motion-planning/motion-group-models`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -10543,7 +8614,7 @@ export const TrajectoryPlanningApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Validate the planned trajectory and load it into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the cached trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion.
+         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion.
          * @summary Plan Trajectory
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {PlanTrajectoryRequest} [planTrajectoryRequest]
@@ -10589,6 +8660,20 @@ export const TrajectoryPlanningApiAxiosParamCreator = function (configuration) {
 export const TrajectoryPlanningApiFp = function (configuration) {
     const localVarAxiosParamCreator = TrajectoryPlanningApiAxiosParamCreator(configuration);
     return {
+        /**
+         * Returns the default collision link chain for a given motion group model.  See [getPlanningMotionGroupModels](getPlanningMotionGroupModels) for supported motion group models.  The default link chain is derived from 3D models and optimized for collision detection within NOVA.  The default link chain includes link shapes only. It does not include any attached components like wire feeders or sensors.  Use the `stored_link_chain` or `link_chain` field in [storeCollisionScene](storeCollisionScene) to attach additional shapes to the link reference frames. Additional shapes may overlap each other per link and may also overlap the respective link\'s default shape.
+         * @summary Get Default Link Chain
+         * @param {string} cell Unique identifier addressing a cell in all API calls.
+         * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g. &#x60;UniversalRobots_UR10e&#x60;.  Get the &#x60;model&#x60; of a configured motion group with [getOptimizerConfiguration](getOptimizerConfiguration).
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getDefaultLinkChain(cell, motionGroupModel, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getDefaultLinkChain(cell, motionGroupModel, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['TrajectoryPlanningApi.getDefaultLinkChain']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * Returns motion group models that are supported for planning.
          * @summary Motion Group Models for Planning
@@ -10596,14 +8681,14 @@ export const TrajectoryPlanningApiFp = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async getPlanningMotionGroupModels(cell, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getPlanningMotionGroupModels(cell, options);
+        async getMotionGroupModelsForPlanning(cell, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getMotionGroupModelsForPlanning(cell, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['TrajectoryPlanningApi.getPlanningMotionGroupModels']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['TrajectoryPlanningApi.getMotionGroupModelsForPlanning']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Validate the planned trajectory and load it into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the cached trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion.
+         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion.
          * @summary Plan Trajectory
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {PlanTrajectoryRequest} [planTrajectoryRequest]
@@ -10625,6 +8710,17 @@ export const TrajectoryPlanningApiFp = function (configuration) {
 export const TrajectoryPlanningApiFactory = function (configuration, basePath, axios) {
     const localVarFp = TrajectoryPlanningApiFp(configuration);
     return {
+        /**
+         * Returns the default collision link chain for a given motion group model.  See [getPlanningMotionGroupModels](getPlanningMotionGroupModels) for supported motion group models.  The default link chain is derived from 3D models and optimized for collision detection within NOVA.  The default link chain includes link shapes only. It does not include any attached components like wire feeders or sensors.  Use the `stored_link_chain` or `link_chain` field in [storeCollisionScene](storeCollisionScene) to attach additional shapes to the link reference frames. Additional shapes may overlap each other per link and may also overlap the respective link\'s default shape.
+         * @summary Get Default Link Chain
+         * @param {string} cell Unique identifier addressing a cell in all API calls.
+         * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g. &#x60;UniversalRobots_UR10e&#x60;.  Get the &#x60;model&#x60; of a configured motion group with [getOptimizerConfiguration](getOptimizerConfiguration).
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getDefaultLinkChain(cell, motionGroupModel, options) {
+            return localVarFp.getDefaultLinkChain(cell, motionGroupModel, options).then((request) => request(axios, basePath));
+        },
         /**
          * Returns motion group models that are supported for planning.
          * @summary Motion Group Models for Planning
@@ -10632,11 +8728,11 @@ export const TrajectoryPlanningApiFactory = function (configuration, basePath, a
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getPlanningMotionGroupModels(cell, options) {
-            return localVarFp.getPlanningMotionGroupModels(cell, options).then((request) => request(axios, basePath));
+        getMotionGroupModelsForPlanning(cell, options) {
+            return localVarFp.getMotionGroupModelsForPlanning(cell, options).then((request) => request(axios, basePath));
         },
         /**
-         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Validate the planned trajectory and load it into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the cached trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion.
+         * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion.
          * @summary Plan Trajectory
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {PlanTrajectoryRequest} [planTrajectoryRequest]
@@ -10655,6 +8751,18 @@ export const TrajectoryPlanningApiFactory = function (configuration, basePath, a
  * @extends {BaseAPI}
  */
 export class TrajectoryPlanningApi extends BaseAPI {
+    /**
+     * Returns the default collision link chain for a given motion group model.  See [getPlanningMotionGroupModels](getPlanningMotionGroupModels) for supported motion group models.  The default link chain is derived from 3D models and optimized for collision detection within NOVA.  The default link chain includes link shapes only. It does not include any attached components like wire feeders or sensors.  Use the `stored_link_chain` or `link_chain` field in [storeCollisionScene](storeCollisionScene) to attach additional shapes to the link reference frames. Additional shapes may overlap each other per link and may also overlap the respective link\'s default shape.
+     * @summary Get Default Link Chain
+     * @param {string} cell Unique identifier addressing a cell in all API calls.
+     * @param {string} motionGroupModel Unique identifier for the model of a motion group, e.g. &#x60;UniversalRobots_UR10e&#x60;.  Get the &#x60;model&#x60; of a configured motion group with [getOptimizerConfiguration](getOptimizerConfiguration).
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof TrajectoryPlanningApi
+     */
+    getDefaultLinkChain(cell, motionGroupModel, options) {
+        return TrajectoryPlanningApiFp(this.configuration).getDefaultLinkChain(cell, motionGroupModel, options).then((request) => request(this.axios, this.basePath));
+    }
     /**
      * Returns motion group models that are supported for planning.
      * @summary Motion Group Models for Planning
@@ -10663,11 +8771,11 @@ export class TrajectoryPlanningApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof TrajectoryPlanningApi
      */
-    getPlanningMotionGroupModels(cell, options) {
-        return TrajectoryPlanningApiFp(this.configuration).getPlanningMotionGroupModels(cell, options).then((request) => request(this.axios, this.basePath));
+    getMotionGroupModelsForPlanning(cell, options) {
+        return TrajectoryPlanningApiFp(this.configuration).getMotionGroupModelsForPlanning(cell, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Validate the planned trajectory and load it into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the cached trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion.
+     * Plans a new trajectory for a single motion group.  Describe the trajectory as a sequence of motion commands that the robots TCP should follow.  Use the following workflow to execute a planned trajectory: 1. Plan a trajectory. 2. Optional: Load the planned trajectory into the cache using the [addTrajectory](addTrajectory) endpoint. 3. Execute the (cached) trajectory using the [executeTrajectory](executeTrajectory) endpoint.  If the trajectory is not executable, the [PlanTrajectoryResponse](PlanTrajectoryResponse) will contain the joint trajectory up until the error, e.g. all samples until a collision occurs. EXCEPTION: If a CartesianPTP or JointPTP motion command has an invalid target, the response will contain the trajectory up until the start of the invalid PTP motion.
      * @summary Plan Trajectory
      * @param {string} cell Unique identifier addressing a cell in all API calls.
      * @param {PlanTrajectoryRequest} [planTrajectoryRequest]
@@ -11243,7 +9351,7 @@ export class VirtualRobotApi extends BaseAPI {
 export const VirtualRobotBehaviorApiAxiosParamCreator = function (configuration) {
     return {
         /**
-         * This stream provides the commanded joint state and sets a motion groups joint configuration, e.g. to move a motion group. The concept is that an application is using the Motion Service to move a motion group. The Motion Service is commanding the desired joint configuration of a motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! It is __not__ providing the *actual* joint state! (Please file a request - if you need a stream of the *actual* joint state)  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configurations. CAUTION: Incoming joint configurations are not visualized and their velocity limits are not checked. we don\'t even check limits!  Possible use cases are: 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion group.  The stream only sends data to the robot controller if a motion is executed.  If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity.  2. Mimic Freedrive motions.  <!-- theme: danger -->  > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits.
+         * <!-- theme: danger -->  > Websocket endpoint  This stream provides the commanded joint state and sets a motion groups joint configuration, e.g. to move a motion group. The concept is that an application is using the Motion Service to move a motion group. The Motion Service is commanding the desired joint configuration of a motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! It is __not__ providing the *actual* joint state! (Please file a request - if you need a stream of the *actual* joint state)  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configurations. CAUTION: Incoming joint configurations are not visualized and their velocity limits are not checked. we don\'t even check limits!  Possible use cases are: 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion group.  The stream only sends data to the robot controller if a motion is executed.  If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity.  2. Mimic Freedrive motions.  <!-- theme: danger -->  > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits.
          * @summary Stream Joint Configuration
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} controller Unique identifier to address a controller in the cell.
@@ -11386,7 +9494,7 @@ export const VirtualRobotBehaviorApiFp = function (configuration) {
     const localVarAxiosParamCreator = VirtualRobotBehaviorApiAxiosParamCreator(configuration);
     return {
         /**
-         * This stream provides the commanded joint state and sets a motion groups joint configuration, e.g. to move a motion group. The concept is that an application is using the Motion Service to move a motion group. The Motion Service is commanding the desired joint configuration of a motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! It is __not__ providing the *actual* joint state! (Please file a request - if you need a stream of the *actual* joint state)  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configurations. CAUTION: Incoming joint configurations are not visualized and their velocity limits are not checked. we don\'t even check limits!  Possible use cases are: 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion group.  The stream only sends data to the robot controller if a motion is executed.  If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity.  2. Mimic Freedrive motions.  <!-- theme: danger -->  > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits.
+         * <!-- theme: danger -->  > Websocket endpoint  This stream provides the commanded joint state and sets a motion groups joint configuration, e.g. to move a motion group. The concept is that an application is using the Motion Service to move a motion group. The Motion Service is commanding the desired joint configuration of a motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! It is __not__ providing the *actual* joint state! (Please file a request - if you need a stream of the *actual* joint state)  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configurations. CAUTION: Incoming joint configurations are not visualized and their velocity limits are not checked. we don\'t even check limits!  Possible use cases are: 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion group.  The stream only sends data to the robot controller if a motion is executed.  If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity.  2. Mimic Freedrive motions.  <!-- theme: danger -->  > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits.
          * @summary Stream Joint Configuration
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} controller Unique identifier to address a controller in the cell.
@@ -11441,7 +9549,7 @@ export const VirtualRobotBehaviorApiFactory = function (configuration, basePath,
     const localVarFp = VirtualRobotBehaviorApiFp(configuration);
     return {
         /**
-         * This stream provides the commanded joint state and sets a motion groups joint configuration, e.g. to move a motion group. The concept is that an application is using the Motion Service to move a motion group. The Motion Service is commanding the desired joint configuration of a motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! It is __not__ providing the *actual* joint state! (Please file a request - if you need a stream of the *actual* joint state)  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configurations. CAUTION: Incoming joint configurations are not visualized and their velocity limits are not checked. we don\'t even check limits!  Possible use cases are: 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion group.  The stream only sends data to the robot controller if a motion is executed.  If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity.  2. Mimic Freedrive motions.  <!-- theme: danger -->  > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits.
+         * <!-- theme: danger -->  > Websocket endpoint  This stream provides the commanded joint state and sets a motion groups joint configuration, e.g. to move a motion group. The concept is that an application is using the Motion Service to move a motion group. The Motion Service is commanding the desired joint configuration of a motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! It is __not__ providing the *actual* joint state! (Please file a request - if you need a stream of the *actual* joint state)  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configurations. CAUTION: Incoming joint configurations are not visualized and their velocity limits are not checked. we don\'t even check limits!  Possible use cases are: 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion group.  The stream only sends data to the robot controller if a motion is executed.  If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity.  2. Mimic Freedrive motions.  <!-- theme: danger -->  > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits.
          * @summary Stream Joint Configuration
          * @param {string} cell Unique identifier addressing a cell in all API calls.
          * @param {string} controller Unique identifier to address a controller in the cell.
@@ -11487,7 +9595,7 @@ export const VirtualRobotBehaviorApiFactory = function (configuration, basePath,
  */
 export class VirtualRobotBehaviorApi extends BaseAPI {
     /**
-     * This stream provides the commanded joint state and sets a motion groups joint configuration, e.g. to move a motion group. The concept is that an application is using the Motion Service to move a motion group. The Motion Service is commanding the desired joint configuration of a motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! It is __not__ providing the *actual* joint state! (Please file a request - if you need a stream of the *actual* joint state)  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configurations. CAUTION: Incoming joint configurations are not visualized and their velocity limits are not checked. we don\'t even check limits!  Possible use cases are: 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion group.  The stream only sends data to the robot controller if a motion is executed.  If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity.  2. Mimic Freedrive motions.  <!-- theme: danger -->  > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits.
+     * <!-- theme: danger -->  > Websocket endpoint  This stream provides the commanded joint state and sets a motion groups joint configuration, e.g. to move a motion group. The concept is that an application is using the Motion Service to move a motion group. The Motion Service is commanding the desired joint configuration of a motion group.  Physical motion groups move to this joint configuration.  With physical motion groups, this takes some time and only works if possible.  And you have the *actual* joint state - the current real motion group configuration.  Again, this stream is providing *commanded* joint state! It is __not__ providing the *actual* joint state! (Please file a request - if you need a stream of the *actual* joint state)  When the virtual controller receives joint commands the joint configuration is immediately adapted to match the incoming joint configurations. CAUTION: Incoming joint configurations are not visualized and their velocity limits are not checked. we don\'t even check limits!  Possible use cases are: 1. Creating a robotic application that dynamically adapts to the configured joints on the robot controller, using this stream to feed new joint configurations back to the motion group.  The stream only sends data to the robot controller if a motion is executed.  If the robot controller\'s joint configuration differs too much from the incoming joint configuration, a following error occurs. Joint configurations that result in following errors are executed only for motions with a low velocity.  2. Mimic Freedrive motions.  <!-- theme: danger -->  > **DANGER** > > If the incoming joint configuration is set to maximum velocity, the movement to reach this incoming joint configuration > will be executed with maximum speed regardless of safety zones and mechanical limits.
      * @summary Stream Joint Configuration
      * @param {string} cell Unique identifier addressing a cell in all API calls.
      * @param {string} controller Unique identifier to address a controller in the cell.