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

package/v2/api.js

@@ -5769,19 +5769,19 @@ export class MotionGroupKinematicsApi extends BaseAPI {
 export const ProgramApiAxiosParamCreator = function (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, request, options = {}) => {
+        createProgramRun: async (cell, programRequest, options = {}) => {
             // 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);
@@ -5798,29 +5798,29 @@ export const ProgramApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            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),
                 options: localVarRequestOptions,
             };
         },
         /**
-         * 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, codeWithArguments, options = {}) => {
+        executeProgram: async (cell, programRequest, options = {}) => {
             // 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.
@@ -5842,28 +5842,28 @@ export const ProgramApiAxiosParamCreator = function (configuration) {
             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),
                 options: localVarRequestOptions,
             };
         },
         /**
-         * 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, runner, options = {}) => {
+        getProgramRun: async (cell, run, options = {}) => {
             // 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;
@@ -5888,16 +5888,16 @@ export const ProgramApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * 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, options = {}) => {
+        getProgramRuns: async (cell, options = {}) => {
             // 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);
@@ -5923,19 +5923,19 @@ export const ProgramApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * 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, request1, options = {}) => {
+        simulateProgram: async (cell, programRequest, options = {}) => {
             // 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);
@@ -5952,31 +5952,27 @@ export const ProgramApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            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),
                 options: localVarRequestOptions,
             };
         },
         /**
-         * 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, request, identifier, options = {}) => {
+        stopAllPrograms: async (cell, options = {}) => {
             // 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);
@@ -5993,31 +5989,30 @@ export const ProgramApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // 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),
                 options: localVarRequestOptions,
             };
         },
         /**
-         * 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, options = {}) => {
+        stopProgramRun: async (cell, run, options = {}) => {
             // 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;
@@ -6042,21 +6037,20 @@ export const ProgramApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * 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, runner, options = {}) => {
+        validateProgram: async (cell, programRequest, options = {}) => {
             // 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;
@@ -6072,9 +6066,11 @@ export const ProgramApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(programRequest, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
@@ -6090,114 +6086,113 @@ export const ProgramApiFp = function (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, request, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.createProgramRunner(cell, request, options);
+        async createProgramRun(cell, programRequest, options) {
+            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, codeWithArguments, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.executeProgram(cell, codeWithArguments, options);
+        async executeProgram(cell, programRequest, options) {
+            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, runner, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getProgramRunner(cell, runner, options);
+        async getProgramRun(cell, run, options) {
+            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, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listProgramRunners(cell, options);
+        async getProgramRuns(cell, options) {
+            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, request1, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.migrateProgram(cell, request1, options);
+        async simulateProgram(cell, programRequest, options) {
+            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, request, identifier, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.planProgram(cell, request, identifier, options);
+        async stopAllPrograms(cell, options) {
+            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, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.stopAllProgramRunner(cell, options);
+        async stopProgramRun(cell, run, options) {
+            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, runner, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.stopProgramRunner(cell, runner, options);
+        async validateProgram(cell, programRequest, options) {
+            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);
         },
     };
@@ -6210,91 +6205,90 @@ export const ProgramApiFactory = function (configuration, basePath, axios) {
     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, request, options) {
-            return localVarFp.createProgramRunner(cell, request, options).then((request) => request(axios, basePath));
+        createProgramRun(cell, programRequest, options) {
+            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, codeWithArguments, options) {
-            return localVarFp.executeProgram(cell, codeWithArguments, options).then((request) => request(axios, basePath));
+        executeProgram(cell, programRequest, options) {
+            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, runner, options) {
-            return localVarFp.getProgramRunner(cell, runner, options).then((request) => request(axios, basePath));
+        getProgramRun(cell, run, options) {
+            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, options) {
-            return localVarFp.listProgramRunners(cell, options).then((request) => request(axios, basePath));
+        getProgramRuns(cell, options) {
+            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, request1, options) {
-            return localVarFp.migrateProgram(cell, request1, options).then((request) => request(axios, basePath));
+        simulateProgram(cell, programRequest, options) {
+            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, request, identifier, options) {
-            return localVarFp.planProgram(cell, request, identifier, options).then((request) => request(axios, basePath));
+        stopAllPrograms(cell, options) {
+            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, options) {
-            return localVarFp.stopAllProgramRunner(cell, options).then((request) => request(axios, basePath));
+        stopProgramRun(cell, run, options) {
+            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, runner, options) {
-            return localVarFp.stopProgramRunner(cell, runner, options).then((request) => request(axios, basePath));
+        validateProgram(cell, programRequest, options) {
+            return localVarFp.validateProgram(cell, programRequest, options).then((request) => request(axios, basePath));
         },
     };
 };
@@ -6306,99 +6300,98 @@ export const ProgramApiFactory = function (configuration, basePath, axios) {
  */
 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
      */
-    createProgramRunner(cell, request, options) {
-        return ProgramApiFp(this.configuration).createProgramRunner(cell, request, options).then((request) => request(this.axios, this.basePath));
+    createProgramRun(cell, programRequest, options) {
+        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
      */
-    executeProgram(cell, codeWithArguments, options) {
-        return ProgramApiFp(this.configuration).executeProgram(cell, codeWithArguments, options).then((request) => request(this.axios, this.basePath));
+    executeProgram(cell, programRequest, options) {
+        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
      */
-    getProgramRunner(cell, runner, options) {
-        return ProgramApiFp(this.configuration).getProgramRunner(cell, runner, options).then((request) => request(this.axios, this.basePath));
+    getProgramRun(cell, run, options) {
+        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
      */
-    listProgramRunners(cell, options) {
-        return ProgramApiFp(this.configuration).listProgramRunners(cell, options).then((request) => request(this.axios, this.basePath));
+    getProgramRuns(cell, options) {
+        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
      */
-    migrateProgram(cell, request1, options) {
-        return ProgramApiFp(this.configuration).migrateProgram(cell, request1, options).then((request) => request(this.axios, this.basePath));
+    simulateProgram(cell, programRequest, options) {
+        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
      */
-    planProgram(cell, request, identifier, options) {
-        return ProgramApiFp(this.configuration).planProgram(cell, request, identifier, options).then((request) => request(this.axios, this.basePath));
+    stopAllPrograms(cell, options) {
+        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
      */
-    stopAllProgramRunner(cell, options) {
-        return ProgramApiFp(this.configuration).stopAllProgramRunner(cell, options).then((request) => request(this.axios, this.basePath));
+    stopProgramRun(cell, run, options) {
+        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
      */
-    stopProgramRunner(cell, runner, options) {
-        return ProgramApiFp(this.configuration).stopProgramRunner(cell, runner, options).then((request) => request(this.axios, this.basePath));
+    validateProgram(cell, programRequest, options) {
+        return ProgramApiFp(this.configuration).validateProgram(cell, programRequest, options).then((request) => request(this.axios, this.basePath));
     }
 }
 /**
@@ -6408,18 +6401,18 @@ export class ProgramApi extends BaseAPI {
 export const ProgramOperatorApiAxiosParamCreator = function (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, createProgramRunRequest, options = {}) => {
+        createProgramOperatorRun: async (cell, createProgramOperatorRunRequest, options = {}) => {
             // 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.
@@ -6441,7 +6434,7 @@ export const ProgramOperatorApiAxiosParamCreator = function (configuration) {
             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),
                 options: localVarRequestOptions,
@@ -6527,16 +6520,16 @@ export const ProgramOperatorApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * <!-- 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, state, options = {}) => {
+        getAllProgramOperatorRuns: async (cell, state, options = {}) => {
             // 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.
@@ -6601,18 +6594,18 @@ export const ProgramOperatorApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * <!-- 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, cell, options = {}) => {
+        getProgramOperatorRun: async (run, cell, options = {}) => {
             // 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)));
@@ -6732,17 +6725,17 @@ export const ProgramOperatorApiFp = function (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, createProgramRunRequest, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.createProgramRun(cell, createProgramRunRequest, options);
+        async createProgramOperatorRun(cell, createProgramOperatorRunRequest, options) {
+            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);
         },
         /**
@@ -6774,17 +6767,17 @@ export const ProgramOperatorApiFp = function (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, state, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getAllProgramRuns(cell, state, options);
+        async getAllProgramOperatorRuns(cell, state, options) {
+            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);
         },
         /**
@@ -6801,17 +6794,17 @@ export const ProgramOperatorApiFp = function (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, cell, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getProgramRun(run, cell, options);
+        async getProgramOperatorRun(run, cell, options) {
+            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);
         },
         /**
@@ -6853,15 +6846,15 @@ export const ProgramOperatorApiFactory = function (configuration, basePath, axio
     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, createProgramRunRequest, options) {
-            return localVarFp.createProgramRun(cell, createProgramRunRequest, options).then((request) => request(axios, basePath));
+        createProgramOperatorRun(cell, createProgramOperatorRunRequest, options) {
+            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.
@@ -6886,15 +6879,15 @@ export const ProgramOperatorApiFactory = function (configuration, basePath, axio
             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, state, options) {
-            return localVarFp.getAllProgramRuns(cell, state, options).then((request) => request(axios, basePath));
+        getAllProgramOperatorRuns(cell, state, options) {
+            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.
@@ -6907,15 +6900,15 @@ export const ProgramOperatorApiFactory = function (configuration, basePath, axio
             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, cell, options) {
-            return localVarFp.getProgramRun(run, cell, options).then((request) => request(axios, basePath));
+        getProgramOperatorRun(run, cell, options) {
+            return localVarFp.getProgramOperatorRun(run, cell, options).then((request) => request(axios, basePath));
         },
         /**
          * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific trigger.
@@ -6950,16 +6943,16 @@ export const ProgramOperatorApiFactory = function (configuration, basePath, axio
  */
 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
      */
-    createProgramRun(cell, createProgramRunRequest, options) {
-        return ProgramOperatorApiFp(this.configuration).createProgramRun(cell, createProgramRunRequest, options).then((request) => request(this.axios, this.basePath));
+    createProgramOperatorRun(cell, createProgramOperatorRunRequest, options) {
+        return ProgramOperatorApiFp(this.configuration).createProgramOperatorRun(cell, createProgramOperatorRunRequest, options).then((request) => request(this.axios, this.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.
@@ -6986,7 +6979,7 @@ export class ProgramOperatorApi extends BaseAPI {
         return ProgramOperatorApiFp(this.configuration).deleteTrigger(trigger, cell, options).then((request) => request(this.axios, this.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]
@@ -6994,8 +6987,8 @@ export class ProgramOperatorApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof ProgramOperatorApi
      */
-    getAllProgramRuns(cell, state, options) {
-        return ProgramOperatorApiFp(this.configuration).getAllProgramRuns(cell, state, options).then((request) => request(this.axios, this.basePath));
+    getAllProgramOperatorRuns(cell, state, options) {
+        return ProgramOperatorApiFp(this.configuration).getAllProgramOperatorRuns(cell, state, options).then((request) => request(this.axios, this.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.
@@ -7009,7 +7002,7 @@ export class ProgramOperatorApi extends BaseAPI {
         return ProgramOperatorApiFp(this.configuration).getAllTriggers(cell, options).then((request) => request(this.axios, this.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.
@@ -7017,8 +7010,8 @@ export class ProgramOperatorApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof ProgramOperatorApi
      */
-    getProgramRun(run, cell, options) {
-        return ProgramOperatorApiFp(this.configuration).getProgramRun(run, cell, options).then((request) => request(this.axios, this.basePath));
+    getProgramOperatorRun(run, cell, options) {
+        return ProgramOperatorApiFp(this.configuration).getProgramOperatorRun(run, cell, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific trigger.