@wandelbots/nova-api 25.5.0-dev.12 → 25.5.0-dev.14

package/v2/api.ts

@@ -249,118 +249,6 @@ export interface App {
      */
     'health_path'?: string;
 }
-/**
- * 
- * @export
- * @interface ArrayInput
- */
-export interface ArrayInput {
-    /**
-     * 
-     * @type {Array<ArrayInputArrayInner>}
-     * @memberof ArrayInput
-     */
-    'array': Array<ArrayInputArrayInner>;
-}
-/**
- * 
- * @export
- * @interface ArrayInputArrayInner
- */
-export interface ArrayInputArrayInner {
-    /**
-     * 
-     * @type {Array<any>}
-     * @memberof ArrayInputArrayInner
-     */
-    'pose': Array<any>;
-    /**
-     * 
-     * @type {Array<any>}
-     * @memberof ArrayInputArrayInner
-     */
-    'position': Array<any>;
-    /**
-     * 
-     * @type {Array<any>}
-     * @memberof ArrayInputArrayInner
-     */
-    'orientation': Array<any>;
-    /**
-     * 
-     * @type {string}
-     * @memberof ArrayInputArrayInner
-     */
-    'image': string;
-    /**
-     * 
-     * @type {string}
-     * @memberof ArrayInputArrayInner
-     */
-    'pointcloud': string;
-    /**
-     * 
-     * @type {Array<ArrayInputArrayInner>}
-     * @memberof ArrayInputArrayInner
-     */
-    'array': Array<ArrayInputArrayInner>;
-}
-/**
- * 
- * @export
- * @interface ArrayOutput
- */
-export interface ArrayOutput {
-    /**
-     * 
-     * @type {Array<ArrayOutputArrayInner>}
-     * @memberof ArrayOutput
-     */
-    'array': Array<ArrayOutputArrayInner>;
-}
-/**
- * 
- * @export
- * @interface ArrayOutputArrayInner
- */
-export interface ArrayOutputArrayInner {
-    /**
-     * 
-     * @type {Array<any>}
-     * @memberof ArrayOutputArrayInner
-     */
-    'pose': Array<any>;
-    /**
-     * 
-     * @type {Array<any>}
-     * @memberof ArrayOutputArrayInner
-     */
-    'position': Array<any>;
-    /**
-     * 
-     * @type {Array<any>}
-     * @memberof ArrayOutputArrayInner
-     */
-    'orientation': Array<any>;
-    /**
-     * 
-     * @type {string}
-     * @memberof ArrayOutputArrayInner
-     */
-    'image': string;
-    /**
-     * 
-     * @type {string}
-     * @memberof ArrayOutputArrayInner
-     */
-    'pointcloud': string;
-    /**
-     * 
-     * @type {Array<ArrayOutputArrayInner>}
-     * @memberof ArrayOutputArrayInner
-     */
-    'array': Array<ArrayOutputArrayInner>;
-}
 /**
  * ## BEHAVIOR_AUTOMATIC This is the default behavior. The motion group instantly takes any commanded joint configuration as actual joint state. Configures the compliance of the virtual robot with the normal ControllerState cycle time. If set, the virtual robot will act like a physical one, e.g. with a cycle time of 8ms to respond to a new joint state command. ## BEHAVIOR_AUTOMATIC_NOT_COMPLY_WITH_CYCLETIME Configures the compliance of the virtual robot with the normal ControllerState cycle time. If set, the robot will respond as fast as possible, limited only by software execution speed. Because of that the execution of a movement requires less time than with BEHAVIOR_AUTOMATIC. ## BEHAVIOR_EXTERNAL_SOURCE The external client is the only source of actual joint state changes. This mode is used to enable third party software indicating the current joint state via [externalJointsStream](externalJointsStream). 
  * @export
@@ -594,19 +482,6 @@ export const Capsule2ShapeTypeEnum = {
 
 export type Capsule2ShapeTypeEnum = typeof Capsule2ShapeTypeEnum[keyof typeof Capsule2ShapeTypeEnum];
 
-/**
- * 
- * @export
- * @interface Capture
- */
-export interface Capture {
-    /**
-     * 
-     * @type {string}
-     * @memberof Capture
-     */
-    'image': string;
-}
 /**
  * To create a robot cell, only a valid name is required. Once created, a robot cell provides access to the Wandelbots NOVA foundation services. The configuration can be customized, e.g. robot controllers, also within apps. 
  * @export
@@ -638,25 +513,6 @@ export interface Cell {
      */
     'apps'?: Array<App>;
 }
-/**
- * 
- * @export
- * @interface CodeWithArguments
- */
-export interface CodeWithArguments {
-    /**
-     * Wandelscript code string which describes a Wandelscript Program as content/json.
-     * @type {string}
-     * @memberof CodeWithArguments
-     */
-    'code': string;
-    /**
-     * 
-     * @type {{ [key: string]: ArrayInputArrayInner; }}
-     * @memberof CodeWithArguments
-     */
-    'initial_state'?: { [key: string]: ArrayInputArrayInner; } | null;
-}
 /**
  * Defines a collider with a single shape.  A collider is an object that is used for collision detection. It defines the `shape` that is attached with the offset of `pose` to a reference frame.  Use colliders to: - Define the shape of a workpiece. The reference frame is the scene origin. - Define the shape of a link in a motion group. The reference frame is the link coordinate system. - Define the shape of a tool. The reference frame is the flange coordinate system. 
  * @export
@@ -1188,26 +1044,26 @@ export interface CoordinateSystems {
 /**
  * 
  * @export
- * @interface CreateProgramRun200Response
+ * @interface CreateProgramOperatorRun200Response
  */
-export interface CreateProgramRun200Response {
+export interface CreateProgramOperatorRun200Response {
     /**
      * The identifier of the program run for further inspection of the running program. 
      * @type {string}
-     * @memberof CreateProgramRun200Response
+     * @memberof CreateProgramOperatorRun200Response
      */
     'id'?: string;
 }
 /**
  * 
  * @export
- * @interface CreateProgramRunRequest
+ * @interface CreateProgramOperatorRunRequest
  */
-export interface CreateProgramRunRequest {
+export interface CreateProgramOperatorRunRequest {
     /**
      * The identifier of the program stored in the program library.
      * @type {string}
-     * @memberof CreateProgramRunRequest
+     * @memberof CreateProgramOperatorRunRequest
      */
     'program_id': string;
 }
@@ -1434,31 +1290,6 @@ export type ExecuteTrajectoryRequest = InitializeMovementRequest | PauseMovement
  */
 export type ExecuteTrajectoryResponse = InitializeMovementResponse | Movement | MovementError | PauseMovementResponse | PlaybackSpeedResponse | Standstill;
 
-/**
- * The ExecutionResult object contains the execution results of a robot.  Arguments:     motion_group_id: The unique identifier of the motion group     motion_duration: The total execution duration of the motion group     paths: The paths of the motion group as list of Path objects
- * @export
- * @interface ExecutionResult
- */
-export interface ExecutionResult {
-    /**
-     * 
-     * @type {string}
-     * @memberof ExecutionResult
-     */
-    'motion_group_id': string;
-    /**
-     * 
-     * @type {number}
-     * @memberof ExecutionResult
-     */
-    'motion_duration': number;
-    /**
-     * 
-     * @type {Array<Path>}
-     * @memberof ExecutionResult
-     */
-    'paths': Array<Path>;
-}
 /**
  * A datapoint inside external joint stream.
  * @export
@@ -1803,13 +1634,13 @@ export interface Geometry {
 /**
  * 
  * @export
- * @interface GetAllProgramRuns200Response
+ * @interface GetAllProgramOperatorRuns200Response
  */
-export interface GetAllProgramRuns200Response {
+export interface GetAllProgramOperatorRuns200Response {
     /**
      * 
      * @type {Array<ProgramRunObject>}
-     * @memberof GetAllProgramRuns200Response
+     * @memberof GetAllProgramOperatorRuns200Response
      */
     'program_runs'?: Array<ProgramRunObject>;
 }
@@ -3969,19 +3800,6 @@ export const OrientationType = {
 export type OrientationType = typeof OrientationType[keyof typeof OrientationType];
 
 
-/**
- * 
- * @export
- * @interface Path
- */
-export interface Path {
-    /**
-     * 
-     * @type {Array<RobotState>}
-     * @memberof Path
-     */
-    'poses'?: Array<RobotState>;
-}
 /**
  * A cartesian point-to-point is representing a joint point-to-point motion from start point to the indicated target pose. The target pose is a joint point-to-point given in cartesian space. The target joint configuration will be calculated to be in the same kinematic configuration as the start point is. If that is not possible, planning will fail. 
  * @export
@@ -4504,19 +4322,6 @@ export interface PlaybackSpeedResponsePlaybackSpeedResponse {
      */
     'requested_value': number;
 }
-/**
- * 
- * @export
- * @interface PointCloud
- */
-export interface PointCloud {
-    /**
-     * 
-     * @type {string}
-     * @memberof PointCloud
-     */
-    'pointcloud': string;
-}
 /**
  * Defines a pose in 3D space. A pose is a combination of a position and an orientation. The position is applied before the orientation. 
  * @export
@@ -4564,17 +4369,48 @@ export interface PoseInCoordinateSystem {
 /**
  * 
  * @export
+ * @interface ProgramRequest
+ */
+export interface ProgramRequest {
+    /**
+     * 
+     * @type {string}
+     * @memberof ProgramRequest
+     */
+    'program'?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof ProgramRequest
+     */
+    'default_robot'?: string | null;
+    /**
+     * 
+     * @type {string}
+     * @memberof ProgramRequest
+     */
+    'default_tcp'?: string | null;
+    /**
+     * Initial arguments that are available within the program
+     * @type {{ [key: string]: RunArgsValue; }}
+     * @memberof ProgramRequest
+     */
+    'run_args'?: { [key: string]: RunArgsValue; };
+}
+/**
+ * Holds the state of a program run.  Args:     id: The unique id of the program run     state: The state of the program run     logs: The logs of the program run     stdout: The stdout of the program run     store: The store of the program run     error: The error message of the program run, if any     traceback: The traceback of the program run, if any     start_time: The start time of the program run     end_time: The end time of the program run     execution_results: The robot execution results of the program run
+ * @export
  * @interface ProgramRun
  */
 export interface ProgramRun {
     /**
-     * 
+     * Unique id of the program run
      * @type {string}
      * @memberof ProgramRun
      */
     'id': string;
     /**
-     * 
+     * State of the program run
      * @type {ProgramRunState}
      * @memberof ProgramRun
      */
@@ -4584,15 +4420,15 @@ export interface ProgramRun {
      * @type {string}
      * @memberof ProgramRun
      */
-    'logs'?: string;
+    'logs'?: string | null;
     /**
      * 
      * @type {string}
      * @memberof ProgramRun
      */
-    'stdout'?: string;
+    'stdout'?: string | null;
     /**
-     * 
+     * Stores runtime variables of the run
      * @type {{ [key: string]: StoreValue; }}
      * @memberof ProgramRun
      */
@@ -4622,11 +4458,11 @@ export interface ProgramRun {
      */
     'end_time'?: number | null;
     /**
-     * 
-     * @type {Array<ExecutionResult>}
+     * Execution results of the program run
+     * @type {Array<ProgramRunResult>}
      * @memberof ProgramRun
      */
-    'execution_results'?: Array<ExecutionResult>;
+    'execution_results'?: Array<ProgramRunResult>;
 }
 
 
@@ -4676,99 +4512,66 @@ export interface ProgramRunObject {
 /**
  * 
  * @export
- * @enum {string}
+ * @interface ProgramRunReference
  */
-
-export const ProgramRunState = {
-    NotStarted: 'not started',
-    Running: 'running',
-    Completed: 'completed',
-    Failed: 'failed',
-    Stopped: 'stopped'
-} as const;
-
-export type ProgramRunState = typeof ProgramRunState[keyof typeof ProgramRunState];
-
-
-/**
- * 
- * @export
- * @interface ProgramRunnerReference
- */
-export interface ProgramRunnerReference {
+export interface ProgramRunReference {
     /**
      * 
      * @type {string}
-     * @memberof ProgramRunnerReference
+     * @memberof ProgramRunReference
      */
     'id': string;
     /**
      * 
      * @type {ProgramRunState}
-     * @memberof ProgramRunnerReference
+     * @memberof ProgramRunReference
      */
     'state': ProgramRunState;
 }
 
 
 /**
- * A pose (position and orientation)
+ * The ProgramRunResult object contains the execution results of a robot.  Arguments:     motion_group_id: The unique id of the motion group     motion_duration: The total execution duration of the motion group     paths: The paths of the motion group as list of Path objects
  * @export
- * @interface PyjectoryDatatypesCorePose
+ * @interface ProgramRunResult
  */
-export interface PyjectoryDatatypesCorePose {
+export interface ProgramRunResult {
     /**
-     * 
-     * @type {Array<any>}
-     * @memberof PyjectoryDatatypesCorePose
-     */
-    'position': Array<any>;
-    /**
-     * 
-     * @type {Array<any>}
-     * @memberof PyjectoryDatatypesCorePose
+     * Unique id of the motion group that was executed
+     * @type {string}
+     * @memberof ProgramRunResult
      */
-    'orientation': Array<any>;
-}
-/**
- * Rotation vector, defined in [rx, ry, rz] with floating numbers. The rotation is represented in vector3 using an axis-angle representation: axis.normalized * angle (angle in radians). Must be defined for the first pose of a path. If not defined for the rest of the path, the previous orientation will be used.
- * @export
- * @interface PyjectoryDatatypesSerializerOrientation
- */
-export interface PyjectoryDatatypesSerializerOrientation {
+    'motion_group_id': string;
     /**
-     * 
-     * @type {Array<any>}
-     * @memberof PyjectoryDatatypesSerializerOrientation
+     * Total execution duration of the motion group
+     * @type {number}
+     * @memberof ProgramRunResult
      */
-    'orientation': Array<any>;
-}
-/**
- * Object\'s position and orientaton, defined in [x, y, z, rx, ry, rz]. x,y,z are defined in millimeters. rx,ry,rz are defined in radians.
- * @export
- * @interface PyjectoryDatatypesSerializerPose
- */
-export interface PyjectoryDatatypesSerializerPose {
+    'motion_duration': number;
     /**
-     * 
-     * @type {Array<any>}
-     * @memberof PyjectoryDatatypesSerializerPose
+     * Paths of the motion group as list of Path objects
+     * @type {Array<Array<RobotState>>}
+     * @memberof ProgramRunResult
      */
-    'pose': Array<any>;
+    'paths': Array<Array<RobotState>>;
 }
 /**
- * Single point, defined in [x, y, z] with floating numbers. Must be defined.
+ * 
  * @export
- * @interface PyjectoryDatatypesSerializerPosition
+ * @enum {string}
  */
-export interface PyjectoryDatatypesSerializerPosition {
-    /**
-     * 
-     * @type {Array<any>}
-     * @memberof PyjectoryDatatypesSerializerPosition
-     */
-    'position': Array<any>;
-}
+
+export const ProgramRunState = {
+    NotStarted: 'not started',
+    Running: 'running',
+    Completed: 'completed',
+    Failed: 'failed',
+    Stopped: 'stopped'
+} as const;
+
+export type ProgramRunState = typeof ProgramRunState[keyof typeof ProgramRunState];
+
+
 /**
  * Defines an x-y plane with finite size.
  * @export
@@ -4897,44 +4700,6 @@ export const ReleaseChannel = {
 export type ReleaseChannel = typeof ReleaseChannel[keyof typeof ReleaseChannel];
 
 
-/**
- * Wandelscript code string which describes a Program as text/plain
- * @export
- * @interface Request
- */
-export interface Request {
-    /**
-     * Wandelscript code string which describes a Wandelscript Program as content/json.
-     * @type {string}
-     * @memberof Request
-     */
-    'code': string;
-    /**
-     * 
-     * @type {{ [key: string]: ArrayInputArrayInner; }}
-     * @memberof Request
-     */
-    'initial_state'?: { [key: string]: ArrayInputArrayInner; };
-}
-/**
- * Wandelscript code string which describes a program
- * @export
- * @interface Request1
- */
-export interface Request1 {
-    /**
-     * Wandelscript code string which describes a Wandelscript Program as content/json.
-     * @type {string}
-     * @memberof Request1
-     */
-    'code': string;
-    /**
-     * 
-     * @type {{ [key: string]: ArrayInputArrayInner; }}
-     * @memberof Request1
-     */
-    'initial_state'?: { [key: string]: ArrayInputArrayInner; };
-}
 /**
  * The configuration of a physical or virtual robot controller.
  * @export
@@ -5032,10 +4797,10 @@ export interface RobotLinkGeometry {
 export interface RobotState {
     /**
      * 
-     * @type {PyjectoryDatatypesCorePose}
+     * @type {Pose}
      * @memberof RobotState
      */
-    'pose': PyjectoryDatatypesCorePose;
+    'pose': Pose;
     /**
      * 
      * @type {Array<number>}
@@ -5112,6 +4877,13 @@ export interface RobotTcps {
      */
     'tcps': Array<RobotTcp>;
 }
+/**
+ * 
+ * @export
+ * @interface RunArgsValue
+ */
+export interface RunArgsValue {
+}
 /**
  * The safety configuration of a motion-group. Used for motion planning.
  * @export
@@ -5656,41 +5428,17 @@ export interface StartOnIO {
  */
 export interface StoreValue {
     /**
-     * 
-     * @type {Array<any>}
-     * @memberof StoreValue
-     */
-    'pose': Array<any>;
-    /**
-     * 
-     * @type {Array<any>}
-     * @memberof StoreValue
-     */
-    'position': Array<any>;
-    /**
-     * 
-     * @type {Array<any>}
-     * @memberof StoreValue
-     */
-    'orientation': Array<any>;
-    /**
-     * 
-     * @type {string}
-     * @memberof StoreValue
-     */
-    'image': string;
-    /**
-     * 
-     * @type {string}
+     * A three-dimensional vector [x, y, z] with double precision. 
+     * @type {Array<number>}
      * @memberof StoreValue
      */
-    'pointcloud': string;
+    'position'?: Array<number>;
     /**
-     * 
-     * @type {Array<ArrayOutputArrayInner>}
+     * Defines a rotation in 3D space. A three-dimensional Vector [rx, ry, rz] with double precision. Rotation is applied around the vector. The angle of rotation equals the length of the vector. 
+     * @type {Array<number>}
      * @memberof StoreValue
      */
-    'array': Array<ArrayOutputArrayInner>;
+    'orientation'?: Array<number>;
 }
 /**
  * Representing a robot pose in operational space aware of a configured TCP.
@@ -12056,19 +11804,19 @@ export class MotionGroupKinematicsApi extends BaseAPI {
 export const ProgramApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
         /**
-         * This endpoint accepts a program written in Wandelscript and if desired, initial arguments (in the form of a dict). It will then execute this Wandelscript asynchronously. It returns a program runner reference which can be used to query the state of the program runner.  ## Parameters See the **Schema** tab for information about the request body.  ## Returns A program runner reference which can be used to query the state of the program runner.  ## Receiving state updates Receive state updates of the program runner via polling the `/programs/runners/{runner_id}/`  ### Via polling You can receive updates about the state of the program runner by polling the `/programs/runners/{runner_id}/` endpoint. ```
-         * @summary Create Program Runner
+         * This endpoint accepts a program and if desired, initial arguments (in the form of a dict).  The program will be executed asynchronously.  It returns a program run reference which can be used to query the state of the program run.  ## Receiving state updates Receive state updates of the program run via polling the `/programs/runs/{run_id}/`  ### Via polling You can receive updates about the state of the program run by polling the `/programs/runs/{run_id}/` endpoint. 
+         * @summary Create program run
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {Request} request 
+         * @param {ProgramRequest} programRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        createProgramRunner: async (cell: string, request: Request, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        createProgramRun: async (cell: string, programRequest: ProgramRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('createProgramRunner', 'cell', cell)
-            // verify required parameter 'request' is not null or undefined
-            assertParamExists('createProgramRunner', 'request', request)
-            const localVarPath = `/cells/{cell}/programs/runners`
+            assertParamExists('createProgramRun', 'cell', cell)
+            // verify required parameter 'programRequest' is not null or undefined
+            assertParamExists('createProgramRun', 'programRequest', programRequest)
+            const localVarPath = `/cells/{cell}/programs/runs`
                 .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);
@@ -12091,12 +11839,12 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
 
 
     
-            localVarHeaderParameter['Content-Type'] = 'text/plain';
+            localVarHeaderParameter['Content-Type'] = 'application/json';
 
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-            localVarRequestOptions.data = serializeDataIfNeeded(request, localVarRequestOptions, configuration)
+            localVarRequestOptions.data = serializeDataIfNeeded(programRequest, localVarRequestOptions, configuration)
 
             return {
                 url: toPathString(localVarUrlObj),
@@ -12104,18 +11852,18 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
             };
         },
         /**
-         * Execute a program in Wandelscript. The Wandelscript can also move multiple robots by using the \'do with\' syntax.  The execute operation will be started from the current joint configuration of any addressed robot(s).  Addressed robots have to be in control mode for the execute operation to succeed.  A request to this endpoint will block this endpoint until the program has been executed, or until an error occurs.  The executed movement is returned in case of a succesful execution. Otherwise an error (e.g. out of reach, singularity), is returned.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  * [WandelEngine & Wandelscript Documentation](/docs/docs/wandelscript) 
-         * @summary Execute Program
+         * Execute a program synchronously.  The execute operation will be started from the current joint configuration of any addressed robot(s).  Addressed robots have to be in control mode for the execute operation to succeed.  A request to this endpoint will block this endpoint until the program has been executed, or until an error occurs.  The executed movement is returned in case of a successful execution.  Otherwise an error (e.g. out of reach, singularity), is returned. 
+         * @summary Execute program
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {CodeWithArguments} codeWithArguments 
+         * @param {ProgramRequest} programRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        executeProgram: async (cell: string, codeWithArguments: CodeWithArguments, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        executeProgram: async (cell: string, programRequest: ProgramRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
             assertParamExists('executeProgram', 'cell', cell)
-            // verify required parameter 'codeWithArguments' is not null or undefined
-            assertParamExists('executeProgram', 'codeWithArguments', codeWithArguments)
+            // verify required parameter 'programRequest' is not null or undefined
+            assertParamExists('executeProgram', 'programRequest', programRequest)
             const localVarPath = `/cells/{cell}/programs/execute`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -12144,7 +11892,7 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-            localVarRequestOptions.data = serializeDataIfNeeded(codeWithArguments, localVarRequestOptions, configuration)
+            localVarRequestOptions.data = serializeDataIfNeeded(programRequest, localVarRequestOptions, configuration)
 
             return {
                 url: toPathString(localVarUrlObj),
@@ -12152,21 +11900,21 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
             };
         },
         /**
-         * Returns information about a program currently executed.  When a program is finished: Program response, result, collected Wandelscript logs, etc.  When a program is running: Running status, current executed line, etc.  ## Parameters - **runner_id**: The identifier of the program runner 
-         * @summary Get Program Runner
+         * Returns information about a program currently executed. When a program is finished: Program response, result, collected logs, .. When a program is running: Running status, current executed line, ... 
+         * @summary Get program run
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} runner 
+         * @param {string} run 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getProgramRunner: async (cell: string, runner: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        getProgramRun: async (cell: string, run: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getProgramRunner', 'cell', cell)
-            // verify required parameter 'runner' is not null or undefined
-            assertParamExists('getProgramRunner', 'runner', runner)
-            const localVarPath = `/cells/{cell}/programs/runners/{runner}`
+            assertParamExists('getProgramRun', 'cell', cell)
+            // verify required parameter 'run' is not null or undefined
+            assertParamExists('getProgramRun', 'run', run)
+            const localVarPath = `/cells/{cell}/programs/runs/{run}`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"runner"}}`, encodeURIComponent(String(runner)));
+                .replace(`{${"run"}}`, encodeURIComponent(String(run)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -12198,16 +11946,16 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
             };
         },
         /**
-         * Get details about all existing program runners.
-         * @summary List Program Runners
+         * Get details about all existing runs
+         * @summary List programs
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listProgramRunners: async (cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        getProgramRuns: async (cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('listProgramRunners', 'cell', cell)
-            const localVarPath = `/cells/{cell}/programs/runners`
+            assertParamExists('getProgramRuns', 'cell', cell)
+            const localVarPath = `/cells/{cell}/programs/runs`
                 .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);
@@ -12240,19 +11988,19 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
             };
         },
         /**
-         * Migrate a program  ## Parameters See the **Schema** tab for information about the request body
-         * @summary Migrate Program
+         * Simulate a program given as text/plain
+         * @summary Simulate program
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {Request1} request1 
+         * @param {ProgramRequest} programRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        migrateProgram: async (cell: string, request1: Request1, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        simulateProgram: async (cell: string, programRequest: ProgramRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('migrateProgram', 'cell', cell)
-            // verify required parameter 'request1' is not null or undefined
-            assertParamExists('migrateProgram', 'request1', request1)
-            const localVarPath = `/cells/{cell}/programs/migrate`
+            assertParamExists('simulateProgram', 'cell', cell)
+            // verify required parameter 'programRequest' is not null or undefined
+            assertParamExists('simulateProgram', 'programRequest', programRequest)
+            const localVarPath = `/cells/{cell}/programs/simulate`
                 .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);
@@ -12275,12 +12023,12 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
 
 
     
-            localVarHeaderParameter['Content-Type'] = 'text/plain';
+            localVarHeaderParameter['Content-Type'] = 'application/json';
 
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-            localVarRequestOptions.data = serializeDataIfNeeded(request1, localVarRequestOptions, configuration)
+            localVarRequestOptions.data = serializeDataIfNeeded(programRequest, localVarRequestOptions, configuration)
 
             return {
                 url: toPathString(localVarUrlObj),
@@ -12288,20 +12036,16 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
             };
         },
         /**
-         * Plan a program based on the specified robot type.  The plan operation can be used to check if a Wandelscript is executable, given the current joint configuration of the robot.  If the Wandelscript is executable, the result contains the motion path. If the Wandelscript is not executable, e.g. points that are out of reach, or the joints encounter a singularity, the reason is returned.  The plan operation can be used in other operating modes besides control mode.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  The plan operation can be used in other operating modes besides control mode.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as Content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  * [WandelEngine & Wandelscript Documentation](/docs/docs/wandelscript) 
-         * @summary Plan Program
+         * Stop all runs
+         * @summary Stop all programs
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {Request} request 
-         * @param {string} [identifier] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        planProgram: async (cell: string, request: Request, identifier?: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        stopAllPrograms: async (cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('planProgram', 'cell', cell)
-            // verify required parameter 'request' is not null or undefined
-            assertParamExists('planProgram', 'request', request)
-            const localVarPath = `/cells/{cell}/programs/plan`
+            assertParamExists('stopAllPrograms', 'cell', cell)
+            const localVarPath = `/cells/{cell}/programs/runs/stop`
                 .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);
@@ -12322,18 +12066,11 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration)
 
-            if (identifier !== undefined) {
-                localVarQueryParameter['identifier'] = identifier;
-            }
-
 
     
-            localVarHeaderParameter['Content-Type'] = 'text/plain';
-
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-            localVarRequestOptions.data = serializeDataIfNeeded(request, localVarRequestOptions, configuration)
 
             return {
                 url: toPathString(localVarUrlObj),
@@ -12341,17 +12078,21 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
             };
         },
         /**
-         * Stop all runners.
-         * @summary Stop All Program Runners
+         * Stop a specific program run.
+         * @summary Stop program run
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {string} run 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        stopAllProgramRunner: async (cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        stopProgramRun: async (cell: string, run: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('stopAllProgramRunner', 'cell', cell)
-            const localVarPath = `/cells/{cell}/programs/runners/stop`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
+            assertParamExists('stopProgramRun', 'cell', cell)
+            // verify required parameter 'run' is not null or undefined
+            assertParamExists('stopProgramRun', 'run', run)
+            const localVarPath = `/cells/{cell}/programs/runs/{run}/stop`
+                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
+                .replace(`{${"run"}}`, encodeURIComponent(String(run)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -12383,21 +12124,20 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
             };
         },
         /**
-         * Stop a specific program runner. If the indicated runner was not running, an error will be returned. ## Parameters - **runner_id**: The identifier of the program runner
-         * @summary Stop Program Runner
+         * Validate a program
+         * @summary Validate program
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} runner 
+         * @param {ProgramRequest} programRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        stopProgramRunner: async (cell: string, runner: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        validateProgram: async (cell: string, programRequest: ProgramRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('stopProgramRunner', 'cell', cell)
-            // verify required parameter 'runner' is not null or undefined
-            assertParamExists('stopProgramRunner', 'runner', runner)
-            const localVarPath = `/cells/{cell}/programs/runners/{runner}/stop`
-                .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
-                .replace(`{${"runner"}}`, encodeURIComponent(String(runner)));
+            assertParamExists('validateProgram', 'cell', cell)
+            // verify required parameter 'programRequest' is not null or undefined
+            assertParamExists('validateProgram', 'programRequest', programRequest)
+            const localVarPath = `/cells/{cell}/programs/validate`
+                .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;
@@ -12419,9 +12159,12 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
 
 
     
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(programRequest, localVarRequestOptions, configuration)
 
             return {
                 url: toPathString(localVarUrlObj),
@@ -12439,114 +12182,113 @@ export const ProgramApiFp = function(configuration?: Configuration) {
     const localVarAxiosParamCreator = ProgramApiAxiosParamCreator(configuration)
     return {
         /**
-         * This endpoint accepts a program written in Wandelscript and if desired, initial arguments (in the form of a dict). It will then execute this Wandelscript asynchronously. It returns a program runner reference which can be used to query the state of the program runner.  ## Parameters See the **Schema** tab for information about the request body.  ## Returns A program runner reference which can be used to query the state of the program runner.  ## Receiving state updates Receive state updates of the program runner via polling the `/programs/runners/{runner_id}/`  ### Via polling You can receive updates about the state of the program runner by polling the `/programs/runners/{runner_id}/` endpoint. ```
-         * @summary Create Program Runner
+         * This endpoint accepts a program and if desired, initial arguments (in the form of a dict).  The program will be executed asynchronously.  It returns a program run reference which can be used to query the state of the program run.  ## Receiving state updates Receive state updates of the program run via polling the `/programs/runs/{run_id}/`  ### Via polling You can receive updates about the state of the program run by polling the `/programs/runs/{run_id}/` endpoint. 
+         * @summary Create program run
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {Request} request 
+         * @param {ProgramRequest} programRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async createProgramRunner(cell: string, request: Request, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRunnerReference>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.createProgramRunner(cell, request, options);
+        async createProgramRun(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRunReference>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.createProgramRun(cell, programRequest, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ProgramApi.createProgramRunner']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['ProgramApi.createProgramRun']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Execute a program in Wandelscript. The Wandelscript can also move multiple robots by using the \'do with\' syntax.  The execute operation will be started from the current joint configuration of any addressed robot(s).  Addressed robots have to be in control mode for the execute operation to succeed.  A request to this endpoint will block this endpoint until the program has been executed, or until an error occurs.  The executed movement is returned in case of a succesful execution. Otherwise an error (e.g. out of reach, singularity), is returned.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  * [WandelEngine & Wandelscript Documentation](/docs/docs/wandelscript) 
-         * @summary Execute Program
+         * Execute a program synchronously.  The execute operation will be started from the current joint configuration of any addressed robot(s).  Addressed robots have to be in control mode for the execute operation to succeed.  A request to this endpoint will block this endpoint until the program has been executed, or until an error occurs.  The executed movement is returned in case of a successful execution.  Otherwise an error (e.g. out of reach, singularity), is returned. 
+         * @summary Execute program
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {CodeWithArguments} codeWithArguments 
+         * @param {ProgramRequest} programRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async executeProgram(cell: string, codeWithArguments: CodeWithArguments, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRun>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.executeProgram(cell, codeWithArguments, options);
+        async executeProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRun>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.executeProgram(cell, programRequest, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['ProgramApi.executeProgram']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Returns information about a program currently executed.  When a program is finished: Program response, result, collected Wandelscript logs, etc.  When a program is running: Running status, current executed line, etc.  ## Parameters - **runner_id**: The identifier of the program runner 
-         * @summary Get Program Runner
+         * Returns information about a program currently executed. When a program is finished: Program response, result, collected logs, .. When a program is running: Running status, current executed line, ... 
+         * @summary Get program run
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} runner 
+         * @param {string} run 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async getProgramRunner(cell: string, runner: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRun>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getProgramRunner(cell, runner, options);
+        async getProgramRun(cell: string, run: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRun>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getProgramRun(cell, run, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ProgramApi.getProgramRunner']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['ProgramApi.getProgramRun']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Get details about all existing program runners.
-         * @summary List Program Runners
+         * Get details about all existing runs
+         * @summary List programs
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async listProgramRunners(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<ProgramRunnerReference>>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listProgramRunners(cell, options);
+        async getProgramRuns(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<ProgramRunReference>>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getProgramRuns(cell, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ProgramApi.listProgramRunners']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['ProgramApi.getProgramRuns']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Migrate a program  ## Parameters See the **Schema** tab for information about the request body
-         * @summary Migrate Program
+         * Simulate a program given as text/plain
+         * @summary Simulate program
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {Request1} request1 
+         * @param {ProgramRequest} programRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async migrateProgram(cell: string, request1: Request1, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<string>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.migrateProgram(cell, request1, options);
+        async simulateProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRun>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.simulateProgram(cell, programRequest, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ProgramApi.migrateProgram']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['ProgramApi.simulateProgram']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Plan a program based on the specified robot type.  The plan operation can be used to check if a Wandelscript is executable, given the current joint configuration of the robot.  If the Wandelscript is executable, the result contains the motion path. If the Wandelscript is not executable, e.g. points that are out of reach, or the joints encounter a singularity, the reason is returned.  The plan operation can be used in other operating modes besides control mode.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  The plan operation can be used in other operating modes besides control mode.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as Content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  * [WandelEngine & Wandelscript Documentation](/docs/docs/wandelscript) 
-         * @summary Plan Program
+         * Stop all runs
+         * @summary Stop all programs
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {Request} request 
-         * @param {string} [identifier] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async planProgram(cell: string, request: Request, identifier?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRun>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.planProgram(cell, request, identifier, options);
+        async stopAllPrograms(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<any>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.stopAllPrograms(cell, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ProgramApi.planProgram']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['ProgramApi.stopAllPrograms']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Stop all runners.
-         * @summary Stop All Program Runners
+         * Stop a specific program run.
+         * @summary Stop program run
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {string} run 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async stopAllProgramRunner(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<any>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.stopAllProgramRunner(cell, options);
+        async stopProgramRun(cell: string, run: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.stopProgramRun(cell, run, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ProgramApi.stopAllProgramRunner']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['ProgramApi.stopProgramRun']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Stop a specific program runner. If the indicated runner was not running, an error will be returned. ## Parameters - **runner_id**: The identifier of the program runner
-         * @summary Stop Program Runner
+         * Validate a program
+         * @summary Validate program
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} runner 
+         * @param {ProgramRequest} programRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async stopProgramRunner(cell: string, runner: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.stopProgramRunner(cell, runner, options);
+        async validateProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.validateProgram(cell, programRequest, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ProgramApi.stopProgramRunner']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['ProgramApi.validateProgram']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     }
@@ -12560,91 +12302,90 @@ export const ProgramApiFactory = function (configuration?: Configuration, basePa
     const localVarFp = ProgramApiFp(configuration)
     return {
         /**
-         * This endpoint accepts a program written in Wandelscript and if desired, initial arguments (in the form of a dict). It will then execute this Wandelscript asynchronously. It returns a program runner reference which can be used to query the state of the program runner.  ## Parameters See the **Schema** tab for information about the request body.  ## Returns A program runner reference which can be used to query the state of the program runner.  ## Receiving state updates Receive state updates of the program runner via polling the `/programs/runners/{runner_id}/`  ### Via polling You can receive updates about the state of the program runner by polling the `/programs/runners/{runner_id}/` endpoint. ```
-         * @summary Create Program Runner
+         * This endpoint accepts a program and if desired, initial arguments (in the form of a dict).  The program will be executed asynchronously.  It returns a program run reference which can be used to query the state of the program run.  ## Receiving state updates Receive state updates of the program run via polling the `/programs/runs/{run_id}/`  ### Via polling You can receive updates about the state of the program run by polling the `/programs/runs/{run_id}/` endpoint. 
+         * @summary Create program run
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {Request} request 
+         * @param {ProgramRequest} programRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        createProgramRunner(cell: string, request: Request, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRunnerReference> {
-            return localVarFp.createProgramRunner(cell, request, options).then((request) => request(axios, basePath));
+        createProgramRun(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRunReference> {
+            return localVarFp.createProgramRun(cell, programRequest, options).then((request) => request(axios, basePath));
         },
         /**
-         * Execute a program in Wandelscript. The Wandelscript can also move multiple robots by using the \'do with\' syntax.  The execute operation will be started from the current joint configuration of any addressed robot(s).  Addressed robots have to be in control mode for the execute operation to succeed.  A request to this endpoint will block this endpoint until the program has been executed, or until an error occurs.  The executed movement is returned in case of a succesful execution. Otherwise an error (e.g. out of reach, singularity), is returned.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  * [WandelEngine & Wandelscript Documentation](/docs/docs/wandelscript) 
-         * @summary Execute Program
+         * Execute a program synchronously.  The execute operation will be started from the current joint configuration of any addressed robot(s).  Addressed robots have to be in control mode for the execute operation to succeed.  A request to this endpoint will block this endpoint until the program has been executed, or until an error occurs.  The executed movement is returned in case of a successful execution.  Otherwise an error (e.g. out of reach, singularity), is returned. 
+         * @summary Execute program
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {CodeWithArguments} codeWithArguments 
+         * @param {ProgramRequest} programRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        executeProgram(cell: string, codeWithArguments: CodeWithArguments, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRun> {
-            return localVarFp.executeProgram(cell, codeWithArguments, options).then((request) => request(axios, basePath));
+        executeProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRun> {
+            return localVarFp.executeProgram(cell, programRequest, options).then((request) => request(axios, basePath));
         },
         /**
-         * Returns information about a program currently executed.  When a program is finished: Program response, result, collected Wandelscript logs, etc.  When a program is running: Running status, current executed line, etc.  ## Parameters - **runner_id**: The identifier of the program runner 
-         * @summary Get Program Runner
+         * Returns information about a program currently executed. When a program is finished: Program response, result, collected logs, .. When a program is running: Running status, current executed line, ... 
+         * @summary Get program run
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} runner 
+         * @param {string} run 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getProgramRunner(cell: string, runner: string, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRun> {
-            return localVarFp.getProgramRunner(cell, runner, options).then((request) => request(axios, basePath));
+        getProgramRun(cell: string, run: string, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRun> {
+            return localVarFp.getProgramRun(cell, run, options).then((request) => request(axios, basePath));
         },
         /**
-         * Get details about all existing program runners.
-         * @summary List Program Runners
+         * Get details about all existing runs
+         * @summary List programs
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listProgramRunners(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<ProgramRunnerReference>> {
-            return localVarFp.listProgramRunners(cell, options).then((request) => request(axios, basePath));
+        getProgramRuns(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<ProgramRunReference>> {
+            return localVarFp.getProgramRuns(cell, options).then((request) => request(axios, basePath));
         },
         /**
-         * Migrate a program  ## Parameters See the **Schema** tab for information about the request body
-         * @summary Migrate Program
+         * Simulate a program given as text/plain
+         * @summary Simulate program
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {Request1} request1 
+         * @param {ProgramRequest} programRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        migrateProgram(cell: string, request1: Request1, options?: RawAxiosRequestConfig): AxiosPromise<string> {
-            return localVarFp.migrateProgram(cell, request1, options).then((request) => request(axios, basePath));
+        simulateProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRun> {
+            return localVarFp.simulateProgram(cell, programRequest, options).then((request) => request(axios, basePath));
         },
         /**
-         * Plan a program based on the specified robot type.  The plan operation can be used to check if a Wandelscript is executable, given the current joint configuration of the robot.  If the Wandelscript is executable, the result contains the motion path. If the Wandelscript is not executable, e.g. points that are out of reach, or the joints encounter a singularity, the reason is returned.  The plan operation can be used in other operating modes besides control mode.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  The plan operation can be used in other operating modes besides control mode.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as Content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  * [WandelEngine & Wandelscript Documentation](/docs/docs/wandelscript) 
-         * @summary Plan Program
+         * Stop all runs
+         * @summary Stop all programs
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {Request} request 
-         * @param {string} [identifier] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        planProgram(cell: string, request: Request, identifier?: string, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRun> {
-            return localVarFp.planProgram(cell, request, identifier, options).then((request) => request(axios, basePath));
+        stopAllPrograms(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<any> {
+            return localVarFp.stopAllPrograms(cell, options).then((request) => request(axios, basePath));
         },
         /**
-         * Stop all runners.
-         * @summary Stop All Program Runners
+         * Stop a specific program run.
+         * @summary Stop program run
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
+         * @param {string} run 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        stopAllProgramRunner(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<any> {
-            return localVarFp.stopAllProgramRunner(cell, options).then((request) => request(axios, basePath));
+        stopProgramRun(cell: string, run: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.stopProgramRun(cell, run, options).then((request) => request(axios, basePath));
         },
         /**
-         * Stop a specific program runner. If the indicated runner was not running, an error will be returned. ## Parameters - **runner_id**: The identifier of the program runner
-         * @summary Stop Program Runner
+         * Validate a program
+         * @summary Validate program
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {string} runner 
+         * @param {ProgramRequest} programRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        stopProgramRunner(cell: string, runner: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
-            return localVarFp.stopProgramRunner(cell, runner, options).then((request) => request(axios, basePath));
+        validateProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.validateProgram(cell, programRequest, options).then((request) => request(axios, basePath));
         },
     };
 };
@@ -12657,106 +12398,105 @@ export const ProgramApiFactory = function (configuration?: Configuration, basePa
  */
 export class ProgramApi extends BaseAPI {
     /**
-     * This endpoint accepts a program written in Wandelscript and if desired, initial arguments (in the form of a dict). It will then execute this Wandelscript asynchronously. It returns a program runner reference which can be used to query the state of the program runner.  ## Parameters See the **Schema** tab for information about the request body.  ## Returns A program runner reference which can be used to query the state of the program runner.  ## Receiving state updates Receive state updates of the program runner via polling the `/programs/runners/{runner_id}/`  ### Via polling You can receive updates about the state of the program runner by polling the `/programs/runners/{runner_id}/` endpoint. ```
-     * @summary Create Program Runner
+     * This endpoint accepts a program and if desired, initial arguments (in the form of a dict).  The program will be executed asynchronously.  It returns a program run reference which can be used to query the state of the program run.  ## Receiving state updates Receive state updates of the program run via polling the `/programs/runs/{run_id}/`  ### Via polling You can receive updates about the state of the program run by polling the `/programs/runs/{run_id}/` endpoint. 
+     * @summary Create program run
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {Request} request 
+     * @param {ProgramRequest} programRequest 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ProgramApi
      */
-    public createProgramRunner(cell: string, request: Request, options?: RawAxiosRequestConfig) {
-        return ProgramApiFp(this.configuration).createProgramRunner(cell, request, options).then((request) => request(this.axios, this.basePath));
+    public createProgramRun(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig) {
+        return ProgramApiFp(this.configuration).createProgramRun(cell, programRequest, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Execute a program in Wandelscript. The Wandelscript can also move multiple robots by using the \'do with\' syntax.  The execute operation will be started from the current joint configuration of any addressed robot(s).  Addressed robots have to be in control mode for the execute operation to succeed.  A request to this endpoint will block this endpoint until the program has been executed, or until an error occurs.  The executed movement is returned in case of a succesful execution. Otherwise an error (e.g. out of reach, singularity), is returned.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  * [WandelEngine & Wandelscript Documentation](/docs/docs/wandelscript) 
-     * @summary Execute Program
+     * Execute a program synchronously.  The execute operation will be started from the current joint configuration of any addressed robot(s).  Addressed robots have to be in control mode for the execute operation to succeed.  A request to this endpoint will block this endpoint until the program has been executed, or until an error occurs.  The executed movement is returned in case of a successful execution.  Otherwise an error (e.g. out of reach, singularity), is returned. 
+     * @summary Execute program
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {CodeWithArguments} codeWithArguments 
+     * @param {ProgramRequest} programRequest 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ProgramApi
      */
-    public executeProgram(cell: string, codeWithArguments: CodeWithArguments, options?: RawAxiosRequestConfig) {
-        return ProgramApiFp(this.configuration).executeProgram(cell, codeWithArguments, options).then((request) => request(this.axios, this.basePath));
+    public executeProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig) {
+        return ProgramApiFp(this.configuration).executeProgram(cell, programRequest, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Returns information about a program currently executed.  When a program is finished: Program response, result, collected Wandelscript logs, etc.  When a program is running: Running status, current executed line, etc.  ## Parameters - **runner_id**: The identifier of the program runner 
-     * @summary Get Program Runner
+     * Returns information about a program currently executed. When a program is finished: Program response, result, collected logs, .. When a program is running: Running status, current executed line, ... 
+     * @summary Get program run
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {string} runner 
+     * @param {string} run 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ProgramApi
      */
-    public getProgramRunner(cell: string, runner: string, options?: RawAxiosRequestConfig) {
-        return ProgramApiFp(this.configuration).getProgramRunner(cell, runner, options).then((request) => request(this.axios, this.basePath));
+    public getProgramRun(cell: string, run: string, options?: RawAxiosRequestConfig) {
+        return ProgramApiFp(this.configuration).getProgramRun(cell, run, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Get details about all existing program runners.
-     * @summary List Program Runners
+     * Get details about all existing runs
+     * @summary List programs
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ProgramApi
      */
-    public listProgramRunners(cell: string, options?: RawAxiosRequestConfig) {
-        return ProgramApiFp(this.configuration).listProgramRunners(cell, options).then((request) => request(this.axios, this.basePath));
+    public getProgramRuns(cell: string, options?: RawAxiosRequestConfig) {
+        return ProgramApiFp(this.configuration).getProgramRuns(cell, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Migrate a program  ## Parameters See the **Schema** tab for information about the request body
-     * @summary Migrate Program
+     * Simulate a program given as text/plain
+     * @summary Simulate program
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {Request1} request1 
+     * @param {ProgramRequest} programRequest 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ProgramApi
      */
-    public migrateProgram(cell: string, request1: Request1, options?: RawAxiosRequestConfig) {
-        return ProgramApiFp(this.configuration).migrateProgram(cell, request1, options).then((request) => request(this.axios, this.basePath));
+    public simulateProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig) {
+        return ProgramApiFp(this.configuration).simulateProgram(cell, programRequest, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Plan a program based on the specified robot type.  The plan operation can be used to check if a Wandelscript is executable, given the current joint configuration of the robot.  If the Wandelscript is executable, the result contains the motion path. If the Wandelscript is not executable, e.g. points that are out of reach, or the joints encounter a singularity, the reason is returned.  The plan operation can be used in other operating modes besides control mode.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  The plan operation can be used in other operating modes besides control mode.  The Wandelscript can either be submitted as is, using Content-type text/plain, or as Content-type application/json with the Wandelscript under \"code\" alongside a set of values provided under \"initial_state\".  * [WandelEngine & Wandelscript Documentation](/docs/docs/wandelscript) 
-     * @summary Plan Program
+     * Stop all runs
+     * @summary Stop all programs
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {Request} request 
-     * @param {string} [identifier] 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ProgramApi
      */
-    public planProgram(cell: string, request: Request, identifier?: string, options?: RawAxiosRequestConfig) {
-        return ProgramApiFp(this.configuration).planProgram(cell, request, identifier, options).then((request) => request(this.axios, this.basePath));
+    public stopAllPrograms(cell: string, options?: RawAxiosRequestConfig) {
+        return ProgramApiFp(this.configuration).stopAllPrograms(cell, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Stop all runners.
-     * @summary Stop All Program Runners
+     * Stop a specific program run.
+     * @summary Stop program run
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
+     * @param {string} run 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ProgramApi
      */
-    public stopAllProgramRunner(cell: string, options?: RawAxiosRequestConfig) {
-        return ProgramApiFp(this.configuration).stopAllProgramRunner(cell, options).then((request) => request(this.axios, this.basePath));
+    public stopProgramRun(cell: string, run: string, options?: RawAxiosRequestConfig) {
+        return ProgramApiFp(this.configuration).stopProgramRun(cell, run, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Stop a specific program runner. If the indicated runner was not running, an error will be returned. ## Parameters - **runner_id**: The identifier of the program runner
-     * @summary Stop Program Runner
+     * Validate a program
+     * @summary Validate program
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {string} runner 
+     * @param {ProgramRequest} programRequest 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ProgramApi
      */
-    public stopProgramRunner(cell: string, runner: string, options?: RawAxiosRequestConfig) {
-        return ProgramApiFp(this.configuration).stopProgramRunner(cell, runner, options).then((request) => request(this.axios, this.basePath));
+    public validateProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig) {
+        return ProgramApiFp(this.configuration).validateProgram(cell, programRequest, options).then((request) => request(this.axios, this.basePath));
     }
 }
 
@@ -12769,18 +12509,18 @@ export class ProgramApi extends BaseAPI {
 export const ProgramOperatorApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
         /**
-         * <!-- theme: danger --> > **Experimental** This endpoint initiates the execution of a program stored in the program library. A program is started with the a specific program id that exists in the program library. 
+         * <!-- theme: danger -->  > **Experimental**  This endpoint initiates the execution of a program stored in the program library. A program is started with the a specific program id that exists in the program library. 
          * @summary Run Program from Library
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {CreateProgramRunRequest} createProgramRunRequest 
+         * @param {CreateProgramOperatorRunRequest} createProgramOperatorRunRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        createProgramRun: async (cell: string, createProgramRunRequest: CreateProgramRunRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        createProgramOperatorRun: async (cell: string, createProgramOperatorRunRequest: CreateProgramOperatorRunRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('createProgramRun', 'cell', cell)
-            // verify required parameter 'createProgramRunRequest' is not null or undefined
-            assertParamExists('createProgramRun', 'createProgramRunRequest', createProgramRunRequest)
+            assertParamExists('createProgramOperatorRun', 'cell', cell)
+            // verify required parameter 'createProgramOperatorRunRequest' is not null or undefined
+            assertParamExists('createProgramOperatorRun', 'createProgramOperatorRunRequest', createProgramOperatorRunRequest)
             const localVarPath = `/cells/{cell}/operator/programs/runs`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -12809,7 +12549,7 @@ export const ProgramOperatorApiAxiosParamCreator = function (configuration?: Con
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-            localVarRequestOptions.data = serializeDataIfNeeded(createProgramRunRequest, localVarRequestOptions, configuration)
+            localVarRequestOptions.data = serializeDataIfNeeded(createProgramOperatorRunRequest, localVarRequestOptions, configuration)
 
             return {
                 url: toPathString(localVarUrlObj),
@@ -12911,16 +12651,16 @@ export const ProgramOperatorApiAxiosParamCreator = function (configuration?: Con
             };
         },
         /**
-         * <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status. 
+         * <!-- theme: danger -->  > **Experimental**  Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status. 
          * @summary Get All Program Runs
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {string} [state] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getAllProgramRuns: async (cell: string, state?: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        getAllProgramOperatorRuns: async (cell: string, state?: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getAllProgramRuns', 'cell', cell)
+            assertParamExists('getAllProgramOperatorRuns', 'cell', cell)
             const localVarPath = `/cells/{cell}/operator/programs/runs`
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -13000,18 +12740,18 @@ export const ProgramOperatorApiAxiosParamCreator = function (configuration?: Con
             };
         },
         /**
-         * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run. 
+         * <!-- theme: danger -->  > **Experimental**  Retrieves detailed information about a specific program run. 
          * @summary Get Program Run
          * @param {string} run 
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getProgramRun: async (run: string, cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        getProgramOperatorRun: async (run: string, cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'run' is not null or undefined
-            assertParamExists('getProgramRun', 'run', run)
+            assertParamExists('getProgramOperatorRun', 'run', run)
             // verify required parameter 'cell' is not null or undefined
-            assertParamExists('getProgramRun', 'cell', cell)
+            assertParamExists('getProgramOperatorRun', 'cell', cell)
             const localVarPath = `/cells/{cell}/operator/programs/runs/{run}`
                 .replace(`{${"run"}}`, encodeURIComponent(String(run)))
                 .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
@@ -13154,17 +12894,17 @@ export const ProgramOperatorApiFp = function(configuration?: Configuration) {
     const localVarAxiosParamCreator = ProgramOperatorApiAxiosParamCreator(configuration)
     return {
         /**
-         * <!-- theme: danger --> > **Experimental** This endpoint initiates the execution of a program stored in the program library. A program is started with the a specific program id that exists in the program library. 
+         * <!-- theme: danger -->  > **Experimental**  This endpoint initiates the execution of a program stored in the program library. A program is started with the a specific program id that exists in the program library. 
          * @summary Run Program from Library
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {CreateProgramRunRequest} createProgramRunRequest 
+         * @param {CreateProgramOperatorRunRequest} createProgramOperatorRunRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async createProgramRun(cell: string, createProgramRunRequest: CreateProgramRunRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CreateProgramRun200Response>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.createProgramRun(cell, createProgramRunRequest, options);
+        async createProgramOperatorRun(cell: string, createProgramOperatorRunRequest: CreateProgramOperatorRunRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CreateProgramOperatorRun200Response>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.createProgramOperatorRun(cell, createProgramOperatorRunRequest, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.createProgramRun']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.createProgramOperatorRun']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -13196,17 +12936,17 @@ export const ProgramOperatorApiFp = function(configuration?: Configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status. 
+         * <!-- theme: danger -->  > **Experimental**  Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status. 
          * @summary Get All Program Runs
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {string} [state] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async getAllProgramRuns(cell: string, state?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GetAllProgramRuns200Response>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getAllProgramRuns(cell, state, options);
+        async getAllProgramOperatorRuns(cell: string, state?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GetAllProgramOperatorRuns200Response>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getAllProgramOperatorRuns(cell, state, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.getAllProgramRuns']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.getAllProgramOperatorRuns']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -13223,17 +12963,17 @@ export const ProgramOperatorApiFp = function(configuration?: Configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run. 
+         * <!-- theme: danger -->  > **Experimental**  Retrieves detailed information about a specific program run. 
          * @summary Get Program Run
          * @param {string} run 
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async getProgramRun(run: string, cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRunObject>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getProgramRun(run, cell, options);
+        async getProgramOperatorRun(run: string, cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRunObject>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getProgramOperatorRun(run, cell, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.getProgramRun']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.getProgramOperatorRun']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -13276,15 +13016,15 @@ export const ProgramOperatorApiFactory = function (configuration?: Configuration
     const localVarFp = ProgramOperatorApiFp(configuration)
     return {
         /**
-         * <!-- theme: danger --> > **Experimental** This endpoint initiates the execution of a program stored in the program library. A program is started with the a specific program id that exists in the program library. 
+         * <!-- theme: danger -->  > **Experimental**  This endpoint initiates the execution of a program stored in the program library. A program is started with the a specific program id that exists in the program library. 
          * @summary Run Program from Library
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
-         * @param {CreateProgramRunRequest} createProgramRunRequest 
+         * @param {CreateProgramOperatorRunRequest} createProgramOperatorRunRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        createProgramRun(cell: string, createProgramRunRequest: CreateProgramRunRequest, options?: RawAxiosRequestConfig): AxiosPromise<CreateProgramRun200Response> {
-            return localVarFp.createProgramRun(cell, createProgramRunRequest, options).then((request) => request(axios, basePath));
+        createProgramOperatorRun(cell: string, createProgramOperatorRunRequest: CreateProgramOperatorRunRequest, options?: RawAxiosRequestConfig): AxiosPromise<CreateProgramOperatorRun200Response> {
+            return localVarFp.createProgramOperatorRun(cell, createProgramOperatorRunRequest, options).then((request) => request(axios, basePath));
         },
         /**
          * <!-- theme: danger --> > **Experimental** Creates a new trigger that automatically runs a program when certain conditions are met. Each trigger has a different configuration, and the configuration must be valid for the provided trigger type. 
@@ -13309,15 +13049,15 @@ export const ProgramOperatorApiFactory = function (configuration?: Configuration
             return localVarFp.deleteTrigger(trigger, cell, options).then((request) => request(axios, basePath));
         },
         /**
-         * <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status. 
+         * <!-- theme: danger -->  > **Experimental**  Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status. 
          * @summary Get All Program Runs
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {string} [state] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getAllProgramRuns(cell: string, state?: string, options?: RawAxiosRequestConfig): AxiosPromise<GetAllProgramRuns200Response> {
-            return localVarFp.getAllProgramRuns(cell, state, options).then((request) => request(axios, basePath));
+        getAllProgramOperatorRuns(cell: string, state?: string, options?: RawAxiosRequestConfig): AxiosPromise<GetAllProgramOperatorRuns200Response> {
+            return localVarFp.getAllProgramOperatorRuns(cell, state, options).then((request) => request(axios, basePath));
         },
         /**
          * <!-- theme: danger --> > **Experimental** Returns all triggers in the system with the program runs caused by each trigger. You can use the program run id to get more details about a specific program run. 
@@ -13330,15 +13070,15 @@ export const ProgramOperatorApiFactory = function (configuration?: Configuration
             return localVarFp.getAllTriggers(cell, options).then((request) => request(axios, basePath));
         },
         /**
-         * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run. 
+         * <!-- theme: danger -->  > **Experimental**  Retrieves detailed information about a specific program run. 
          * @summary Get Program Run
          * @param {string} run 
          * @param {string} cell Unique identifier addressing a cell in all API calls. 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getProgramRun(run: string, cell: string, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRunObject> {
-            return localVarFp.getProgramRun(run, cell, options).then((request) => request(axios, basePath));
+        getProgramOperatorRun(run: string, cell: string, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRunObject> {
+            return localVarFp.getProgramOperatorRun(run, cell, options).then((request) => request(axios, basePath));
         },
         /**
          * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific trigger. 
@@ -13374,16 +13114,16 @@ export const ProgramOperatorApiFactory = function (configuration?: Configuration
  */
 export class ProgramOperatorApi extends BaseAPI {
     /**
-     * <!-- theme: danger --> > **Experimental** This endpoint initiates the execution of a program stored in the program library. A program is started with the a specific program id that exists in the program library. 
+     * <!-- theme: danger -->  > **Experimental**  This endpoint initiates the execution of a program stored in the program library. A program is started with the a specific program id that exists in the program library. 
      * @summary Run Program from Library
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
-     * @param {CreateProgramRunRequest} createProgramRunRequest 
+     * @param {CreateProgramOperatorRunRequest} createProgramOperatorRunRequest 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof ProgramOperatorApi
      */
-    public createProgramRun(cell: string, createProgramRunRequest: CreateProgramRunRequest, options?: RawAxiosRequestConfig) {
-        return ProgramOperatorApiFp(this.configuration).createProgramRun(cell, createProgramRunRequest, options).then((request) => request(this.axios, this.basePath));
+    public createProgramOperatorRun(cell: string, createProgramOperatorRunRequest: CreateProgramOperatorRunRequest, options?: RawAxiosRequestConfig) {
+        return ProgramOperatorApiFp(this.configuration).createProgramOperatorRun(cell, createProgramOperatorRunRequest, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -13413,7 +13153,7 @@ export class ProgramOperatorApi extends BaseAPI {
     }
 
     /**
-     * <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status. 
+     * <!-- theme: danger -->  > **Experimental**  Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status. 
      * @summary Get All Program Runs
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
      * @param {string} [state] 
@@ -13421,8 +13161,8 @@ export class ProgramOperatorApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof ProgramOperatorApi
      */
-    public getAllProgramRuns(cell: string, state?: string, options?: RawAxiosRequestConfig) {
-        return ProgramOperatorApiFp(this.configuration).getAllProgramRuns(cell, state, options).then((request) => request(this.axios, this.basePath));
+    public getAllProgramOperatorRuns(cell: string, state?: string, options?: RawAxiosRequestConfig) {
+        return ProgramOperatorApiFp(this.configuration).getAllProgramOperatorRuns(cell, state, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -13438,7 +13178,7 @@ export class ProgramOperatorApi extends BaseAPI {
     }
 
     /**
-     * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run. 
+     * <!-- theme: danger -->  > **Experimental**  Retrieves detailed information about a specific program run. 
      * @summary Get Program Run
      * @param {string} run 
      * @param {string} cell Unique identifier addressing a cell in all API calls. 
@@ -13446,8 +13186,8 @@ export class ProgramOperatorApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof ProgramOperatorApi
      */
-    public getProgramRun(run: string, cell: string, options?: RawAxiosRequestConfig) {
-        return ProgramOperatorApiFp(this.configuration).getProgramRun(run, cell, options).then((request) => request(this.axios, this.basePath));
+    public getProgramOperatorRun(run: string, cell: string, options?: RawAxiosRequestConfig) {
+        return ProgramOperatorApiFp(this.configuration).getProgramOperatorRun(run, cell, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**