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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/package.json +1 -1
  2. package/v2/api.d.ts +242 -502
  3. package/v2/api.js +235 -242
  4. package/v2/api.js.map +1 -1
  5. package/v2/api.ts +332 -592
package/v2/api.js CHANGED
@@ -5769,19 +5769,19 @@ export class MotionGroupKinematicsApi extends BaseAPI {
5769
5769
  export const ProgramApiAxiosParamCreator = function (configuration) {
5770
5770
  return {
5771
5771
  /**
5772
- * 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. ```
5773
- * @summary Create Program Runner
5772
+ * 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.
5773
+ * @summary Create program run
5774
5774
  * @param {string} cell Unique identifier addressing a cell in all API calls.
5775
- * @param {Request} request
5775
+ * @param {ProgramRequest} programRequest
5776
5776
  * @param {*} [options] Override http request option.
5777
5777
  * @throws {RequiredError}
5778
5778
  */
5779
- createProgramRunner: async (cell, request, options = {}) => {
5779
+ createProgramRun: async (cell, programRequest, options = {}) => {
5780
5780
  // verify required parameter 'cell' is not null or undefined
5781
- assertParamExists('createProgramRunner', 'cell', cell);
5782
- // verify required parameter 'request' is not null or undefined
5783
- assertParamExists('createProgramRunner', 'request', request);
5784
- const localVarPath = `/cells/{cell}/programs/runners`
5781
+ assertParamExists('createProgramRun', 'cell', cell);
5782
+ // verify required parameter 'programRequest' is not null or undefined
5783
+ assertParamExists('createProgramRun', 'programRequest', programRequest);
5784
+ const localVarPath = `/cells/{cell}/programs/runs`
5785
5785
  .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
5786
5786
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
5787
5787
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -5798,29 +5798,29 @@ export const ProgramApiAxiosParamCreator = function (configuration) {
5798
5798
  // authentication BearerAuth required
5799
5799
  // http bearer authentication required
5800
5800
  await setBearerAuthToObject(localVarHeaderParameter, configuration);
5801
- localVarHeaderParameter['Content-Type'] = 'text/plain';
5801
+ localVarHeaderParameter['Content-Type'] = 'application/json';
5802
5802
  setSearchParams(localVarUrlObj, localVarQueryParameter);
5803
5803
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
5804
5804
  localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
5805
- localVarRequestOptions.data = serializeDataIfNeeded(request, localVarRequestOptions, configuration);
5805
+ localVarRequestOptions.data = serializeDataIfNeeded(programRequest, localVarRequestOptions, configuration);
5806
5806
  return {
5807
5807
  url: toPathString(localVarUrlObj),
5808
5808
  options: localVarRequestOptions,
5809
5809
  };
5810
5810
  },
5811
5811
  /**
5812
- * 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)
5813
- * @summary Execute Program
5812
+ * 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.
5813
+ * @summary Execute program
5814
5814
  * @param {string} cell Unique identifier addressing a cell in all API calls.
5815
- * @param {CodeWithArguments} codeWithArguments
5815
+ * @param {ProgramRequest} programRequest
5816
5816
  * @param {*} [options] Override http request option.
5817
5817
  * @throws {RequiredError}
5818
5818
  */
5819
- executeProgram: async (cell, codeWithArguments, options = {}) => {
5819
+ executeProgram: async (cell, programRequest, options = {}) => {
5820
5820
  // verify required parameter 'cell' is not null or undefined
5821
5821
  assertParamExists('executeProgram', 'cell', cell);
5822
- // verify required parameter 'codeWithArguments' is not null or undefined
5823
- assertParamExists('executeProgram', 'codeWithArguments', codeWithArguments);
5822
+ // verify required parameter 'programRequest' is not null or undefined
5823
+ assertParamExists('executeProgram', 'programRequest', programRequest);
5824
5824
  const localVarPath = `/cells/{cell}/programs/execute`
5825
5825
  .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
5826
5826
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -5842,28 +5842,28 @@ export const ProgramApiAxiosParamCreator = function (configuration) {
5842
5842
  setSearchParams(localVarUrlObj, localVarQueryParameter);
5843
5843
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
5844
5844
  localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
5845
- localVarRequestOptions.data = serializeDataIfNeeded(codeWithArguments, localVarRequestOptions, configuration);
5845
+ localVarRequestOptions.data = serializeDataIfNeeded(programRequest, localVarRequestOptions, configuration);
5846
5846
  return {
5847
5847
  url: toPathString(localVarUrlObj),
5848
5848
  options: localVarRequestOptions,
5849
5849
  };
5850
5850
  },
5851
5851
  /**
5852
- * 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
5853
- * @summary Get Program Runner
5852
+ * 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, ...
5853
+ * @summary Get program run
5854
5854
  * @param {string} cell Unique identifier addressing a cell in all API calls.
5855
- * @param {string} runner
5855
+ * @param {string} run
5856
5856
  * @param {*} [options] Override http request option.
5857
5857
  * @throws {RequiredError}
5858
5858
  */
5859
- getProgramRunner: async (cell, runner, options = {}) => {
5859
+ getProgramRun: async (cell, run, options = {}) => {
5860
5860
  // verify required parameter 'cell' is not null or undefined
5861
- assertParamExists('getProgramRunner', 'cell', cell);
5862
- // verify required parameter 'runner' is not null or undefined
5863
- assertParamExists('getProgramRunner', 'runner', runner);
5864
- const localVarPath = `/cells/{cell}/programs/runners/{runner}`
5861
+ assertParamExists('getProgramRun', 'cell', cell);
5862
+ // verify required parameter 'run' is not null or undefined
5863
+ assertParamExists('getProgramRun', 'run', run);
5864
+ const localVarPath = `/cells/{cell}/programs/runs/{run}`
5865
5865
  .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
5866
- .replace(`{${"runner"}}`, encodeURIComponent(String(runner)));
5866
+ .replace(`{${"run"}}`, encodeURIComponent(String(run)));
5867
5867
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
5868
5868
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
5869
5869
  let baseOptions;
@@ -5888,16 +5888,16 @@ export const ProgramApiAxiosParamCreator = function (configuration) {
5888
5888
  };
5889
5889
  },
5890
5890
  /**
5891
- * Get details about all existing program runners.
5892
- * @summary List Program Runners
5891
+ * Get details about all existing runs
5892
+ * @summary List programs
5893
5893
  * @param {string} cell Unique identifier addressing a cell in all API calls.
5894
5894
  * @param {*} [options] Override http request option.
5895
5895
  * @throws {RequiredError}
5896
5896
  */
5897
- listProgramRunners: async (cell, options = {}) => {
5897
+ getProgramRuns: async (cell, options = {}) => {
5898
5898
  // verify required parameter 'cell' is not null or undefined
5899
- assertParamExists('listProgramRunners', 'cell', cell);
5900
- const localVarPath = `/cells/{cell}/programs/runners`
5899
+ assertParamExists('getProgramRuns', 'cell', cell);
5900
+ const localVarPath = `/cells/{cell}/programs/runs`
5901
5901
  .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
5902
5902
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
5903
5903
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -5923,19 +5923,19 @@ export const ProgramApiAxiosParamCreator = function (configuration) {
5923
5923
  };
5924
5924
  },
5925
5925
  /**
5926
- * Migrate a program ## Parameters See the **Schema** tab for information about the request body
5927
- * @summary Migrate Program
5926
+ * Simulate a program given as text/plain
5927
+ * @summary Simulate program
5928
5928
  * @param {string} cell Unique identifier addressing a cell in all API calls.
5929
- * @param {Request1} request1
5929
+ * @param {ProgramRequest} programRequest
5930
5930
  * @param {*} [options] Override http request option.
5931
5931
  * @throws {RequiredError}
5932
5932
  */
5933
- migrateProgram: async (cell, request1, options = {}) => {
5933
+ simulateProgram: async (cell, programRequest, options = {}) => {
5934
5934
  // verify required parameter 'cell' is not null or undefined
5935
- assertParamExists('migrateProgram', 'cell', cell);
5936
- // verify required parameter 'request1' is not null or undefined
5937
- assertParamExists('migrateProgram', 'request1', request1);
5938
- const localVarPath = `/cells/{cell}/programs/migrate`
5935
+ assertParamExists('simulateProgram', 'cell', cell);
5936
+ // verify required parameter 'programRequest' is not null or undefined
5937
+ assertParamExists('simulateProgram', 'programRequest', programRequest);
5938
+ const localVarPath = `/cells/{cell}/programs/simulate`
5939
5939
  .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
5940
5940
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
5941
5941
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -5952,31 +5952,27 @@ export const ProgramApiAxiosParamCreator = function (configuration) {
5952
5952
  // authentication BearerAuth required
5953
5953
  // http bearer authentication required
5954
5954
  await setBearerAuthToObject(localVarHeaderParameter, configuration);
5955
- localVarHeaderParameter['Content-Type'] = 'text/plain';
5955
+ localVarHeaderParameter['Content-Type'] = 'application/json';
5956
5956
  setSearchParams(localVarUrlObj, localVarQueryParameter);
5957
5957
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
5958
5958
  localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
5959
- localVarRequestOptions.data = serializeDataIfNeeded(request1, localVarRequestOptions, configuration);
5959
+ localVarRequestOptions.data = serializeDataIfNeeded(programRequest, localVarRequestOptions, configuration);
5960
5960
  return {
5961
5961
  url: toPathString(localVarUrlObj),
5962
5962
  options: localVarRequestOptions,
5963
5963
  };
5964
5964
  },
5965
5965
  /**
5966
- * 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)
5967
- * @summary Plan Program
5966
+ * Stop all runs
5967
+ * @summary Stop all programs
5968
5968
  * @param {string} cell Unique identifier addressing a cell in all API calls.
5969
- * @param {Request} request
5970
- * @param {string} [identifier]
5971
5969
  * @param {*} [options] Override http request option.
5972
5970
  * @throws {RequiredError}
5973
5971
  */
5974
- planProgram: async (cell, request, identifier, options = {}) => {
5972
+ stopAllPrograms: async (cell, options = {}) => {
5975
5973
  // verify required parameter 'cell' is not null or undefined
5976
- assertParamExists('planProgram', 'cell', cell);
5977
- // verify required parameter 'request' is not null or undefined
5978
- assertParamExists('planProgram', 'request', request);
5979
- const localVarPath = `/cells/{cell}/programs/plan`
5974
+ assertParamExists('stopAllPrograms', 'cell', cell);
5975
+ const localVarPath = `/cells/{cell}/programs/runs/stop`
5980
5976
  .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
5981
5977
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
5982
5978
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -5993,31 +5989,30 @@ export const ProgramApiAxiosParamCreator = function (configuration) {
5993
5989
  // authentication BearerAuth required
5994
5990
  // http bearer authentication required
5995
5991
  await setBearerAuthToObject(localVarHeaderParameter, configuration);
5996
- if (identifier !== undefined) {
5997
- localVarQueryParameter['identifier'] = identifier;
5998
- }
5999
- localVarHeaderParameter['Content-Type'] = 'text/plain';
6000
5992
  setSearchParams(localVarUrlObj, localVarQueryParameter);
6001
5993
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
6002
5994
  localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
6003
- localVarRequestOptions.data = serializeDataIfNeeded(request, localVarRequestOptions, configuration);
6004
5995
  return {
6005
5996
  url: toPathString(localVarUrlObj),
6006
5997
  options: localVarRequestOptions,
6007
5998
  };
6008
5999
  },
6009
6000
  /**
6010
- * Stop all runners.
6011
- * @summary Stop All Program Runners
6001
+ * Stop a specific program run.
6002
+ * @summary Stop program run
6012
6003
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6004
+ * @param {string} run
6013
6005
  * @param {*} [options] Override http request option.
6014
6006
  * @throws {RequiredError}
6015
6007
  */
6016
- stopAllProgramRunner: async (cell, options = {}) => {
6008
+ stopProgramRun: async (cell, run, options = {}) => {
6017
6009
  // verify required parameter 'cell' is not null or undefined
6018
- assertParamExists('stopAllProgramRunner', 'cell', cell);
6019
- const localVarPath = `/cells/{cell}/programs/runners/stop`
6020
- .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
6010
+ assertParamExists('stopProgramRun', 'cell', cell);
6011
+ // verify required parameter 'run' is not null or undefined
6012
+ assertParamExists('stopProgramRun', 'run', run);
6013
+ const localVarPath = `/cells/{cell}/programs/runs/{run}/stop`
6014
+ .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
6015
+ .replace(`{${"run"}}`, encodeURIComponent(String(run)));
6021
6016
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
6022
6017
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
6023
6018
  let baseOptions;
@@ -6042,21 +6037,20 @@ export const ProgramApiAxiosParamCreator = function (configuration) {
6042
6037
  };
6043
6038
  },
6044
6039
  /**
6045
- * 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
6046
- * @summary Stop Program Runner
6040
+ * Validate a program
6041
+ * @summary Validate program
6047
6042
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6048
- * @param {string} runner
6043
+ * @param {ProgramRequest} programRequest
6049
6044
  * @param {*} [options] Override http request option.
6050
6045
  * @throws {RequiredError}
6051
6046
  */
6052
- stopProgramRunner: async (cell, runner, options = {}) => {
6047
+ validateProgram: async (cell, programRequest, options = {}) => {
6053
6048
  // verify required parameter 'cell' is not null or undefined
6054
- assertParamExists('stopProgramRunner', 'cell', cell);
6055
- // verify required parameter 'runner' is not null or undefined
6056
- assertParamExists('stopProgramRunner', 'runner', runner);
6057
- const localVarPath = `/cells/{cell}/programs/runners/{runner}/stop`
6058
- .replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
6059
- .replace(`{${"runner"}}`, encodeURIComponent(String(runner)));
6049
+ assertParamExists('validateProgram', 'cell', cell);
6050
+ // verify required parameter 'programRequest' is not null or undefined
6051
+ assertParamExists('validateProgram', 'programRequest', programRequest);
6052
+ const localVarPath = `/cells/{cell}/programs/validate`
6053
+ .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
6060
6054
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
6061
6055
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
6062
6056
  let baseOptions;
@@ -6072,9 +6066,11 @@ export const ProgramApiAxiosParamCreator = function (configuration) {
6072
6066
  // authentication BearerAuth required
6073
6067
  // http bearer authentication required
6074
6068
  await setBearerAuthToObject(localVarHeaderParameter, configuration);
6069
+ localVarHeaderParameter['Content-Type'] = 'application/json';
6075
6070
  setSearchParams(localVarUrlObj, localVarQueryParameter);
6076
6071
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
6077
6072
  localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
6073
+ localVarRequestOptions.data = serializeDataIfNeeded(programRequest, localVarRequestOptions, configuration);
6078
6074
  return {
6079
6075
  url: toPathString(localVarUrlObj),
6080
6076
  options: localVarRequestOptions,
@@ -6090,114 +6086,113 @@ export const ProgramApiFp = function (configuration) {
6090
6086
  const localVarAxiosParamCreator = ProgramApiAxiosParamCreator(configuration);
6091
6087
  return {
6092
6088
  /**
6093
- * 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. ```
6094
- * @summary Create Program Runner
6089
+ * 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.
6090
+ * @summary Create program run
6095
6091
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6096
- * @param {Request} request
6092
+ * @param {ProgramRequest} programRequest
6097
6093
  * @param {*} [options] Override http request option.
6098
6094
  * @throws {RequiredError}
6099
6095
  */
6100
- async createProgramRunner(cell, request, options) {
6101
- const localVarAxiosArgs = await localVarAxiosParamCreator.createProgramRunner(cell, request, options);
6096
+ async createProgramRun(cell, programRequest, options) {
6097
+ const localVarAxiosArgs = await localVarAxiosParamCreator.createProgramRun(cell, programRequest, options);
6102
6098
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
6103
- const localVarOperationServerBasePath = operationServerMap['ProgramApi.createProgramRunner']?.[localVarOperationServerIndex]?.url;
6099
+ const localVarOperationServerBasePath = operationServerMap['ProgramApi.createProgramRun']?.[localVarOperationServerIndex]?.url;
6104
6100
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
6105
6101
  },
6106
6102
  /**
6107
- * 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)
6108
- * @summary Execute Program
6103
+ * 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.
6104
+ * @summary Execute program
6109
6105
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6110
- * @param {CodeWithArguments} codeWithArguments
6106
+ * @param {ProgramRequest} programRequest
6111
6107
  * @param {*} [options] Override http request option.
6112
6108
  * @throws {RequiredError}
6113
6109
  */
6114
- async executeProgram(cell, codeWithArguments, options) {
6115
- const localVarAxiosArgs = await localVarAxiosParamCreator.executeProgram(cell, codeWithArguments, options);
6110
+ async executeProgram(cell, programRequest, options) {
6111
+ const localVarAxiosArgs = await localVarAxiosParamCreator.executeProgram(cell, programRequest, options);
6116
6112
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
6117
6113
  const localVarOperationServerBasePath = operationServerMap['ProgramApi.executeProgram']?.[localVarOperationServerIndex]?.url;
6118
6114
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
6119
6115
  },
6120
6116
  /**
6121
- * 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
6122
- * @summary Get Program Runner
6117
+ * 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, ...
6118
+ * @summary Get program run
6123
6119
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6124
- * @param {string} runner
6120
+ * @param {string} run
6125
6121
  * @param {*} [options] Override http request option.
6126
6122
  * @throws {RequiredError}
6127
6123
  */
6128
- async getProgramRunner(cell, runner, options) {
6129
- const localVarAxiosArgs = await localVarAxiosParamCreator.getProgramRunner(cell, runner, options);
6124
+ async getProgramRun(cell, run, options) {
6125
+ const localVarAxiosArgs = await localVarAxiosParamCreator.getProgramRun(cell, run, options);
6130
6126
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
6131
- const localVarOperationServerBasePath = operationServerMap['ProgramApi.getProgramRunner']?.[localVarOperationServerIndex]?.url;
6127
+ const localVarOperationServerBasePath = operationServerMap['ProgramApi.getProgramRun']?.[localVarOperationServerIndex]?.url;
6132
6128
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
6133
6129
  },
6134
6130
  /**
6135
- * Get details about all existing program runners.
6136
- * @summary List Program Runners
6131
+ * Get details about all existing runs
6132
+ * @summary List programs
6137
6133
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6138
6134
  * @param {*} [options] Override http request option.
6139
6135
  * @throws {RequiredError}
6140
6136
  */
6141
- async listProgramRunners(cell, options) {
6142
- const localVarAxiosArgs = await localVarAxiosParamCreator.listProgramRunners(cell, options);
6137
+ async getProgramRuns(cell, options) {
6138
+ const localVarAxiosArgs = await localVarAxiosParamCreator.getProgramRuns(cell, options);
6143
6139
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
6144
- const localVarOperationServerBasePath = operationServerMap['ProgramApi.listProgramRunners']?.[localVarOperationServerIndex]?.url;
6140
+ const localVarOperationServerBasePath = operationServerMap['ProgramApi.getProgramRuns']?.[localVarOperationServerIndex]?.url;
6145
6141
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
6146
6142
  },
6147
6143
  /**
6148
- * Migrate a program ## Parameters See the **Schema** tab for information about the request body
6149
- * @summary Migrate Program
6144
+ * Simulate a program given as text/plain
6145
+ * @summary Simulate program
6150
6146
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6151
- * @param {Request1} request1
6147
+ * @param {ProgramRequest} programRequest
6152
6148
  * @param {*} [options] Override http request option.
6153
6149
  * @throws {RequiredError}
6154
6150
  */
6155
- async migrateProgram(cell, request1, options) {
6156
- const localVarAxiosArgs = await localVarAxiosParamCreator.migrateProgram(cell, request1, options);
6151
+ async simulateProgram(cell, programRequest, options) {
6152
+ const localVarAxiosArgs = await localVarAxiosParamCreator.simulateProgram(cell, programRequest, options);
6157
6153
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
6158
- const localVarOperationServerBasePath = operationServerMap['ProgramApi.migrateProgram']?.[localVarOperationServerIndex]?.url;
6154
+ const localVarOperationServerBasePath = operationServerMap['ProgramApi.simulateProgram']?.[localVarOperationServerIndex]?.url;
6159
6155
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
6160
6156
  },
6161
6157
  /**
6162
- * 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)
6163
- * @summary Plan Program
6158
+ * Stop all runs
6159
+ * @summary Stop all programs
6164
6160
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6165
- * @param {Request} request
6166
- * @param {string} [identifier]
6167
6161
  * @param {*} [options] Override http request option.
6168
6162
  * @throws {RequiredError}
6169
6163
  */
6170
- async planProgram(cell, request, identifier, options) {
6171
- const localVarAxiosArgs = await localVarAxiosParamCreator.planProgram(cell, request, identifier, options);
6164
+ async stopAllPrograms(cell, options) {
6165
+ const localVarAxiosArgs = await localVarAxiosParamCreator.stopAllPrograms(cell, options);
6172
6166
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
6173
- const localVarOperationServerBasePath = operationServerMap['ProgramApi.planProgram']?.[localVarOperationServerIndex]?.url;
6167
+ const localVarOperationServerBasePath = operationServerMap['ProgramApi.stopAllPrograms']?.[localVarOperationServerIndex]?.url;
6174
6168
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
6175
6169
  },
6176
6170
  /**
6177
- * Stop all runners.
6178
- * @summary Stop All Program Runners
6171
+ * Stop a specific program run.
6172
+ * @summary Stop program run
6179
6173
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6174
+ * @param {string} run
6180
6175
  * @param {*} [options] Override http request option.
6181
6176
  * @throws {RequiredError}
6182
6177
  */
6183
- async stopAllProgramRunner(cell, options) {
6184
- const localVarAxiosArgs = await localVarAxiosParamCreator.stopAllProgramRunner(cell, options);
6178
+ async stopProgramRun(cell, run, options) {
6179
+ const localVarAxiosArgs = await localVarAxiosParamCreator.stopProgramRun(cell, run, options);
6185
6180
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
6186
- const localVarOperationServerBasePath = operationServerMap['ProgramApi.stopAllProgramRunner']?.[localVarOperationServerIndex]?.url;
6181
+ const localVarOperationServerBasePath = operationServerMap['ProgramApi.stopProgramRun']?.[localVarOperationServerIndex]?.url;
6187
6182
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
6188
6183
  },
6189
6184
  /**
6190
- * 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
6191
- * @summary Stop Program Runner
6185
+ * Validate a program
6186
+ * @summary Validate program
6192
6187
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6193
- * @param {string} runner
6188
+ * @param {ProgramRequest} programRequest
6194
6189
  * @param {*} [options] Override http request option.
6195
6190
  * @throws {RequiredError}
6196
6191
  */
6197
- async stopProgramRunner(cell, runner, options) {
6198
- const localVarAxiosArgs = await localVarAxiosParamCreator.stopProgramRunner(cell, runner, options);
6192
+ async validateProgram(cell, programRequest, options) {
6193
+ const localVarAxiosArgs = await localVarAxiosParamCreator.validateProgram(cell, programRequest, options);
6199
6194
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
6200
- const localVarOperationServerBasePath = operationServerMap['ProgramApi.stopProgramRunner']?.[localVarOperationServerIndex]?.url;
6195
+ const localVarOperationServerBasePath = operationServerMap['ProgramApi.validateProgram']?.[localVarOperationServerIndex]?.url;
6201
6196
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
6202
6197
  },
6203
6198
  };
@@ -6210,91 +6205,90 @@ export const ProgramApiFactory = function (configuration, basePath, axios) {
6210
6205
  const localVarFp = ProgramApiFp(configuration);
6211
6206
  return {
6212
6207
  /**
6213
- * 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. ```
6214
- * @summary Create Program Runner
6208
+ * 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.
6209
+ * @summary Create program run
6215
6210
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6216
- * @param {Request} request
6211
+ * @param {ProgramRequest} programRequest
6217
6212
  * @param {*} [options] Override http request option.
6218
6213
  * @throws {RequiredError}
6219
6214
  */
6220
- createProgramRunner(cell, request, options) {
6221
- return localVarFp.createProgramRunner(cell, request, options).then((request) => request(axios, basePath));
6215
+ createProgramRun(cell, programRequest, options) {
6216
+ return localVarFp.createProgramRun(cell, programRequest, options).then((request) => request(axios, basePath));
6222
6217
  },
6223
6218
  /**
6224
- * 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)
6225
- * @summary Execute Program
6219
+ * 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.
6220
+ * @summary Execute program
6226
6221
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6227
- * @param {CodeWithArguments} codeWithArguments
6222
+ * @param {ProgramRequest} programRequest
6228
6223
  * @param {*} [options] Override http request option.
6229
6224
  * @throws {RequiredError}
6230
6225
  */
6231
- executeProgram(cell, codeWithArguments, options) {
6232
- return localVarFp.executeProgram(cell, codeWithArguments, options).then((request) => request(axios, basePath));
6226
+ executeProgram(cell, programRequest, options) {
6227
+ return localVarFp.executeProgram(cell, programRequest, options).then((request) => request(axios, basePath));
6233
6228
  },
6234
6229
  /**
6235
- * 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
6236
- * @summary Get Program Runner
6230
+ * 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, ...
6231
+ * @summary Get program run
6237
6232
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6238
- * @param {string} runner
6233
+ * @param {string} run
6239
6234
  * @param {*} [options] Override http request option.
6240
6235
  * @throws {RequiredError}
6241
6236
  */
6242
- getProgramRunner(cell, runner, options) {
6243
- return localVarFp.getProgramRunner(cell, runner, options).then((request) => request(axios, basePath));
6237
+ getProgramRun(cell, run, options) {
6238
+ return localVarFp.getProgramRun(cell, run, options).then((request) => request(axios, basePath));
6244
6239
  },
6245
6240
  /**
6246
- * Get details about all existing program runners.
6247
- * @summary List Program Runners
6241
+ * Get details about all existing runs
6242
+ * @summary List programs
6248
6243
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6249
6244
  * @param {*} [options] Override http request option.
6250
6245
  * @throws {RequiredError}
6251
6246
  */
6252
- listProgramRunners(cell, options) {
6253
- return localVarFp.listProgramRunners(cell, options).then((request) => request(axios, basePath));
6247
+ getProgramRuns(cell, options) {
6248
+ return localVarFp.getProgramRuns(cell, options).then((request) => request(axios, basePath));
6254
6249
  },
6255
6250
  /**
6256
- * Migrate a program ## Parameters See the **Schema** tab for information about the request body
6257
- * @summary Migrate Program
6251
+ * Simulate a program given as text/plain
6252
+ * @summary Simulate program
6258
6253
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6259
- * @param {Request1} request1
6254
+ * @param {ProgramRequest} programRequest
6260
6255
  * @param {*} [options] Override http request option.
6261
6256
  * @throws {RequiredError}
6262
6257
  */
6263
- migrateProgram(cell, request1, options) {
6264
- return localVarFp.migrateProgram(cell, request1, options).then((request) => request(axios, basePath));
6258
+ simulateProgram(cell, programRequest, options) {
6259
+ return localVarFp.simulateProgram(cell, programRequest, options).then((request) => request(axios, basePath));
6265
6260
  },
6266
6261
  /**
6267
- * 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)
6268
- * @summary Plan Program
6262
+ * Stop all runs
6263
+ * @summary Stop all programs
6269
6264
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6270
- * @param {Request} request
6271
- * @param {string} [identifier]
6272
6265
  * @param {*} [options] Override http request option.
6273
6266
  * @throws {RequiredError}
6274
6267
  */
6275
- planProgram(cell, request, identifier, options) {
6276
- return localVarFp.planProgram(cell, request, identifier, options).then((request) => request(axios, basePath));
6268
+ stopAllPrograms(cell, options) {
6269
+ return localVarFp.stopAllPrograms(cell, options).then((request) => request(axios, basePath));
6277
6270
  },
6278
6271
  /**
6279
- * Stop all runners.
6280
- * @summary Stop All Program Runners
6272
+ * Stop a specific program run.
6273
+ * @summary Stop program run
6281
6274
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6275
+ * @param {string} run
6282
6276
  * @param {*} [options] Override http request option.
6283
6277
  * @throws {RequiredError}
6284
6278
  */
6285
- stopAllProgramRunner(cell, options) {
6286
- return localVarFp.stopAllProgramRunner(cell, options).then((request) => request(axios, basePath));
6279
+ stopProgramRun(cell, run, options) {
6280
+ return localVarFp.stopProgramRun(cell, run, options).then((request) => request(axios, basePath));
6287
6281
  },
6288
6282
  /**
6289
- * 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
6290
- * @summary Stop Program Runner
6283
+ * Validate a program
6284
+ * @summary Validate program
6291
6285
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6292
- * @param {string} runner
6286
+ * @param {ProgramRequest} programRequest
6293
6287
  * @param {*} [options] Override http request option.
6294
6288
  * @throws {RequiredError}
6295
6289
  */
6296
- stopProgramRunner(cell, runner, options) {
6297
- return localVarFp.stopProgramRunner(cell, runner, options).then((request) => request(axios, basePath));
6290
+ validateProgram(cell, programRequest, options) {
6291
+ return localVarFp.validateProgram(cell, programRequest, options).then((request) => request(axios, basePath));
6298
6292
  },
6299
6293
  };
6300
6294
  };
@@ -6306,99 +6300,98 @@ export const ProgramApiFactory = function (configuration, basePath, axios) {
6306
6300
  */
6307
6301
  export class ProgramApi extends BaseAPI {
6308
6302
  /**
6309
- * 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. ```
6310
- * @summary Create Program Runner
6303
+ * 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.
6304
+ * @summary Create program run
6311
6305
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6312
- * @param {Request} request
6306
+ * @param {ProgramRequest} programRequest
6313
6307
  * @param {*} [options] Override http request option.
6314
6308
  * @throws {RequiredError}
6315
6309
  * @memberof ProgramApi
6316
6310
  */
6317
- createProgramRunner(cell, request, options) {
6318
- return ProgramApiFp(this.configuration).createProgramRunner(cell, request, options).then((request) => request(this.axios, this.basePath));
6311
+ createProgramRun(cell, programRequest, options) {
6312
+ return ProgramApiFp(this.configuration).createProgramRun(cell, programRequest, options).then((request) => request(this.axios, this.basePath));
6319
6313
  }
6320
6314
  /**
6321
- * 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)
6322
- * @summary Execute Program
6315
+ * 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.
6316
+ * @summary Execute program
6323
6317
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6324
- * @param {CodeWithArguments} codeWithArguments
6318
+ * @param {ProgramRequest} programRequest
6325
6319
  * @param {*} [options] Override http request option.
6326
6320
  * @throws {RequiredError}
6327
6321
  * @memberof ProgramApi
6328
6322
  */
6329
- executeProgram(cell, codeWithArguments, options) {
6330
- return ProgramApiFp(this.configuration).executeProgram(cell, codeWithArguments, options).then((request) => request(this.axios, this.basePath));
6323
+ executeProgram(cell, programRequest, options) {
6324
+ return ProgramApiFp(this.configuration).executeProgram(cell, programRequest, options).then((request) => request(this.axios, this.basePath));
6331
6325
  }
6332
6326
  /**
6333
- * 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
6334
- * @summary Get Program Runner
6327
+ * 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, ...
6328
+ * @summary Get program run
6335
6329
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6336
- * @param {string} runner
6330
+ * @param {string} run
6337
6331
  * @param {*} [options] Override http request option.
6338
6332
  * @throws {RequiredError}
6339
6333
  * @memberof ProgramApi
6340
6334
  */
6341
- getProgramRunner(cell, runner, options) {
6342
- return ProgramApiFp(this.configuration).getProgramRunner(cell, runner, options).then((request) => request(this.axios, this.basePath));
6335
+ getProgramRun(cell, run, options) {
6336
+ return ProgramApiFp(this.configuration).getProgramRun(cell, run, options).then((request) => request(this.axios, this.basePath));
6343
6337
  }
6344
6338
  /**
6345
- * Get details about all existing program runners.
6346
- * @summary List Program Runners
6339
+ * Get details about all existing runs
6340
+ * @summary List programs
6347
6341
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6348
6342
  * @param {*} [options] Override http request option.
6349
6343
  * @throws {RequiredError}
6350
6344
  * @memberof ProgramApi
6351
6345
  */
6352
- listProgramRunners(cell, options) {
6353
- return ProgramApiFp(this.configuration).listProgramRunners(cell, options).then((request) => request(this.axios, this.basePath));
6346
+ getProgramRuns(cell, options) {
6347
+ return ProgramApiFp(this.configuration).getProgramRuns(cell, options).then((request) => request(this.axios, this.basePath));
6354
6348
  }
6355
6349
  /**
6356
- * Migrate a program ## Parameters See the **Schema** tab for information about the request body
6357
- * @summary Migrate Program
6350
+ * Simulate a program given as text/plain
6351
+ * @summary Simulate program
6358
6352
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6359
- * @param {Request1} request1
6353
+ * @param {ProgramRequest} programRequest
6360
6354
  * @param {*} [options] Override http request option.
6361
6355
  * @throws {RequiredError}
6362
6356
  * @memberof ProgramApi
6363
6357
  */
6364
- migrateProgram(cell, request1, options) {
6365
- return ProgramApiFp(this.configuration).migrateProgram(cell, request1, options).then((request) => request(this.axios, this.basePath));
6358
+ simulateProgram(cell, programRequest, options) {
6359
+ return ProgramApiFp(this.configuration).simulateProgram(cell, programRequest, options).then((request) => request(this.axios, this.basePath));
6366
6360
  }
6367
6361
  /**
6368
- * 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)
6369
- * @summary Plan Program
6362
+ * Stop all runs
6363
+ * @summary Stop all programs
6370
6364
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6371
- * @param {Request} request
6372
- * @param {string} [identifier]
6373
6365
  * @param {*} [options] Override http request option.
6374
6366
  * @throws {RequiredError}
6375
6367
  * @memberof ProgramApi
6376
6368
  */
6377
- planProgram(cell, request, identifier, options) {
6378
- return ProgramApiFp(this.configuration).planProgram(cell, request, identifier, options).then((request) => request(this.axios, this.basePath));
6369
+ stopAllPrograms(cell, options) {
6370
+ return ProgramApiFp(this.configuration).stopAllPrograms(cell, options).then((request) => request(this.axios, this.basePath));
6379
6371
  }
6380
6372
  /**
6381
- * Stop all runners.
6382
- * @summary Stop All Program Runners
6373
+ * Stop a specific program run.
6374
+ * @summary Stop program run
6383
6375
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6376
+ * @param {string} run
6384
6377
  * @param {*} [options] Override http request option.
6385
6378
  * @throws {RequiredError}
6386
6379
  * @memberof ProgramApi
6387
6380
  */
6388
- stopAllProgramRunner(cell, options) {
6389
- return ProgramApiFp(this.configuration).stopAllProgramRunner(cell, options).then((request) => request(this.axios, this.basePath));
6381
+ stopProgramRun(cell, run, options) {
6382
+ return ProgramApiFp(this.configuration).stopProgramRun(cell, run, options).then((request) => request(this.axios, this.basePath));
6390
6383
  }
6391
6384
  /**
6392
- * 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
6393
- * @summary Stop Program Runner
6385
+ * Validate a program
6386
+ * @summary Validate program
6394
6387
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6395
- * @param {string} runner
6388
+ * @param {ProgramRequest} programRequest
6396
6389
  * @param {*} [options] Override http request option.
6397
6390
  * @throws {RequiredError}
6398
6391
  * @memberof ProgramApi
6399
6392
  */
6400
- stopProgramRunner(cell, runner, options) {
6401
- return ProgramApiFp(this.configuration).stopProgramRunner(cell, runner, options).then((request) => request(this.axios, this.basePath));
6393
+ validateProgram(cell, programRequest, options) {
6394
+ return ProgramApiFp(this.configuration).validateProgram(cell, programRequest, options).then((request) => request(this.axios, this.basePath));
6402
6395
  }
6403
6396
  }
6404
6397
  /**
@@ -6408,18 +6401,18 @@ export class ProgramApi extends BaseAPI {
6408
6401
  export const ProgramOperatorApiAxiosParamCreator = function (configuration) {
6409
6402
  return {
6410
6403
  /**
6411
- * <!-- 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.
6404
+ * <!-- 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.
6412
6405
  * @summary Run Program from Library
6413
6406
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6414
- * @param {CreateProgramRunRequest} createProgramRunRequest
6407
+ * @param {CreateProgramOperatorRunRequest} createProgramOperatorRunRequest
6415
6408
  * @param {*} [options] Override http request option.
6416
6409
  * @throws {RequiredError}
6417
6410
  */
6418
- createProgramRun: async (cell, createProgramRunRequest, options = {}) => {
6411
+ createProgramOperatorRun: async (cell, createProgramOperatorRunRequest, options = {}) => {
6419
6412
  // verify required parameter 'cell' is not null or undefined
6420
- assertParamExists('createProgramRun', 'cell', cell);
6421
- // verify required parameter 'createProgramRunRequest' is not null or undefined
6422
- assertParamExists('createProgramRun', 'createProgramRunRequest', createProgramRunRequest);
6413
+ assertParamExists('createProgramOperatorRun', 'cell', cell);
6414
+ // verify required parameter 'createProgramOperatorRunRequest' is not null or undefined
6415
+ assertParamExists('createProgramOperatorRun', 'createProgramOperatorRunRequest', createProgramOperatorRunRequest);
6423
6416
  const localVarPath = `/cells/{cell}/operator/programs/runs`
6424
6417
  .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
6425
6418
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -6441,7 +6434,7 @@ export const ProgramOperatorApiAxiosParamCreator = function (configuration) {
6441
6434
  setSearchParams(localVarUrlObj, localVarQueryParameter);
6442
6435
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
6443
6436
  localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
6444
- localVarRequestOptions.data = serializeDataIfNeeded(createProgramRunRequest, localVarRequestOptions, configuration);
6437
+ localVarRequestOptions.data = serializeDataIfNeeded(createProgramOperatorRunRequest, localVarRequestOptions, configuration);
6445
6438
  return {
6446
6439
  url: toPathString(localVarUrlObj),
6447
6440
  options: localVarRequestOptions,
@@ -6527,16 +6520,16 @@ export const ProgramOperatorApiAxiosParamCreator = function (configuration) {
6527
6520
  };
6528
6521
  },
6529
6522
  /**
6530
- * <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status.
6523
+ * <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status.
6531
6524
  * @summary Get All Program Runs
6532
6525
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6533
6526
  * @param {string} [state]
6534
6527
  * @param {*} [options] Override http request option.
6535
6528
  * @throws {RequiredError}
6536
6529
  */
6537
- getAllProgramRuns: async (cell, state, options = {}) => {
6530
+ getAllProgramOperatorRuns: async (cell, state, options = {}) => {
6538
6531
  // verify required parameter 'cell' is not null or undefined
6539
- assertParamExists('getAllProgramRuns', 'cell', cell);
6532
+ assertParamExists('getAllProgramOperatorRuns', 'cell', cell);
6540
6533
  const localVarPath = `/cells/{cell}/operator/programs/runs`
6541
6534
  .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
6542
6535
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -6601,18 +6594,18 @@ export const ProgramOperatorApiAxiosParamCreator = function (configuration) {
6601
6594
  };
6602
6595
  },
6603
6596
  /**
6604
- * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run.
6597
+ * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run.
6605
6598
  * @summary Get Program Run
6606
6599
  * @param {string} run
6607
6600
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6608
6601
  * @param {*} [options] Override http request option.
6609
6602
  * @throws {RequiredError}
6610
6603
  */
6611
- getProgramRun: async (run, cell, options = {}) => {
6604
+ getProgramOperatorRun: async (run, cell, options = {}) => {
6612
6605
  // verify required parameter 'run' is not null or undefined
6613
- assertParamExists('getProgramRun', 'run', run);
6606
+ assertParamExists('getProgramOperatorRun', 'run', run);
6614
6607
  // verify required parameter 'cell' is not null or undefined
6615
- assertParamExists('getProgramRun', 'cell', cell);
6608
+ assertParamExists('getProgramOperatorRun', 'cell', cell);
6616
6609
  const localVarPath = `/cells/{cell}/operator/programs/runs/{run}`
6617
6610
  .replace(`{${"run"}}`, encodeURIComponent(String(run)))
6618
6611
  .replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
@@ -6732,17 +6725,17 @@ export const ProgramOperatorApiFp = function (configuration) {
6732
6725
  const localVarAxiosParamCreator = ProgramOperatorApiAxiosParamCreator(configuration);
6733
6726
  return {
6734
6727
  /**
6735
- * <!-- 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.
6728
+ * <!-- 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.
6736
6729
  * @summary Run Program from Library
6737
6730
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6738
- * @param {CreateProgramRunRequest} createProgramRunRequest
6731
+ * @param {CreateProgramOperatorRunRequest} createProgramOperatorRunRequest
6739
6732
  * @param {*} [options] Override http request option.
6740
6733
  * @throws {RequiredError}
6741
6734
  */
6742
- async createProgramRun(cell, createProgramRunRequest, options) {
6743
- const localVarAxiosArgs = await localVarAxiosParamCreator.createProgramRun(cell, createProgramRunRequest, options);
6735
+ async createProgramOperatorRun(cell, createProgramOperatorRunRequest, options) {
6736
+ const localVarAxiosArgs = await localVarAxiosParamCreator.createProgramOperatorRun(cell, createProgramOperatorRunRequest, options);
6744
6737
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
6745
- const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.createProgramRun']?.[localVarOperationServerIndex]?.url;
6738
+ const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.createProgramOperatorRun']?.[localVarOperationServerIndex]?.url;
6746
6739
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
6747
6740
  },
6748
6741
  /**
@@ -6774,17 +6767,17 @@ export const ProgramOperatorApiFp = function (configuration) {
6774
6767
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
6775
6768
  },
6776
6769
  /**
6777
- * <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status.
6770
+ * <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status.
6778
6771
  * @summary Get All Program Runs
6779
6772
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6780
6773
  * @param {string} [state]
6781
6774
  * @param {*} [options] Override http request option.
6782
6775
  * @throws {RequiredError}
6783
6776
  */
6784
- async getAllProgramRuns(cell, state, options) {
6785
- const localVarAxiosArgs = await localVarAxiosParamCreator.getAllProgramRuns(cell, state, options);
6777
+ async getAllProgramOperatorRuns(cell, state, options) {
6778
+ const localVarAxiosArgs = await localVarAxiosParamCreator.getAllProgramOperatorRuns(cell, state, options);
6786
6779
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
6787
- const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.getAllProgramRuns']?.[localVarOperationServerIndex]?.url;
6780
+ const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.getAllProgramOperatorRuns']?.[localVarOperationServerIndex]?.url;
6788
6781
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
6789
6782
  },
6790
6783
  /**
@@ -6801,17 +6794,17 @@ export const ProgramOperatorApiFp = function (configuration) {
6801
6794
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
6802
6795
  },
6803
6796
  /**
6804
- * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run.
6797
+ * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run.
6805
6798
  * @summary Get Program Run
6806
6799
  * @param {string} run
6807
6800
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6808
6801
  * @param {*} [options] Override http request option.
6809
6802
  * @throws {RequiredError}
6810
6803
  */
6811
- async getProgramRun(run, cell, options) {
6812
- const localVarAxiosArgs = await localVarAxiosParamCreator.getProgramRun(run, cell, options);
6804
+ async getProgramOperatorRun(run, cell, options) {
6805
+ const localVarAxiosArgs = await localVarAxiosParamCreator.getProgramOperatorRun(run, cell, options);
6813
6806
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
6814
- const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.getProgramRun']?.[localVarOperationServerIndex]?.url;
6807
+ const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.getProgramOperatorRun']?.[localVarOperationServerIndex]?.url;
6815
6808
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
6816
6809
  },
6817
6810
  /**
@@ -6853,15 +6846,15 @@ export const ProgramOperatorApiFactory = function (configuration, basePath, axio
6853
6846
  const localVarFp = ProgramOperatorApiFp(configuration);
6854
6847
  return {
6855
6848
  /**
6856
- * <!-- 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.
6849
+ * <!-- 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.
6857
6850
  * @summary Run Program from Library
6858
6851
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6859
- * @param {CreateProgramRunRequest} createProgramRunRequest
6852
+ * @param {CreateProgramOperatorRunRequest} createProgramOperatorRunRequest
6860
6853
  * @param {*} [options] Override http request option.
6861
6854
  * @throws {RequiredError}
6862
6855
  */
6863
- createProgramRun(cell, createProgramRunRequest, options) {
6864
- return localVarFp.createProgramRun(cell, createProgramRunRequest, options).then((request) => request(axios, basePath));
6856
+ createProgramOperatorRun(cell, createProgramOperatorRunRequest, options) {
6857
+ return localVarFp.createProgramOperatorRun(cell, createProgramOperatorRunRequest, options).then((request) => request(axios, basePath));
6865
6858
  },
6866
6859
  /**
6867
6860
  * <!-- 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
6886
6879
  return localVarFp.deleteTrigger(trigger, cell, options).then((request) => request(axios, basePath));
6887
6880
  },
6888
6881
  /**
6889
- * <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status.
6882
+ * <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status.
6890
6883
  * @summary Get All Program Runs
6891
6884
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6892
6885
  * @param {string} [state]
6893
6886
  * @param {*} [options] Override http request option.
6894
6887
  * @throws {RequiredError}
6895
6888
  */
6896
- getAllProgramRuns(cell, state, options) {
6897
- return localVarFp.getAllProgramRuns(cell, state, options).then((request) => request(axios, basePath));
6889
+ getAllProgramOperatorRuns(cell, state, options) {
6890
+ return localVarFp.getAllProgramOperatorRuns(cell, state, options).then((request) => request(axios, basePath));
6898
6891
  },
6899
6892
  /**
6900
6893
  * <!-- 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
6907
6900
  return localVarFp.getAllTriggers(cell, options).then((request) => request(axios, basePath));
6908
6901
  },
6909
6902
  /**
6910
- * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run.
6903
+ * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run.
6911
6904
  * @summary Get Program Run
6912
6905
  * @param {string} run
6913
6906
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6914
6907
  * @param {*} [options] Override http request option.
6915
6908
  * @throws {RequiredError}
6916
6909
  */
6917
- getProgramRun(run, cell, options) {
6918
- return localVarFp.getProgramRun(run, cell, options).then((request) => request(axios, basePath));
6910
+ getProgramOperatorRun(run, cell, options) {
6911
+ return localVarFp.getProgramOperatorRun(run, cell, options).then((request) => request(axios, basePath));
6919
6912
  },
6920
6913
  /**
6921
6914
  * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific trigger.
@@ -6950,16 +6943,16 @@ export const ProgramOperatorApiFactory = function (configuration, basePath, axio
6950
6943
  */
6951
6944
  export class ProgramOperatorApi extends BaseAPI {
6952
6945
  /**
6953
- * <!-- 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.
6946
+ * <!-- 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.
6954
6947
  * @summary Run Program from Library
6955
6948
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6956
- * @param {CreateProgramRunRequest} createProgramRunRequest
6949
+ * @param {CreateProgramOperatorRunRequest} createProgramOperatorRunRequest
6957
6950
  * @param {*} [options] Override http request option.
6958
6951
  * @throws {RequiredError}
6959
6952
  * @memberof ProgramOperatorApi
6960
6953
  */
6961
- createProgramRun(cell, createProgramRunRequest, options) {
6962
- return ProgramOperatorApiFp(this.configuration).createProgramRun(cell, createProgramRunRequest, options).then((request) => request(this.axios, this.basePath));
6954
+ createProgramOperatorRun(cell, createProgramOperatorRunRequest, options) {
6955
+ return ProgramOperatorApiFp(this.configuration).createProgramOperatorRun(cell, createProgramOperatorRunRequest, options).then((request) => request(this.axios, this.basePath));
6963
6956
  }
6964
6957
  /**
6965
6958
  * <!-- 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 {
6986
6979
  return ProgramOperatorApiFp(this.configuration).deleteTrigger(trigger, cell, options).then((request) => request(this.axios, this.basePath));
6987
6980
  }
6988
6981
  /**
6989
- * <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status.
6982
+ * <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status.
6990
6983
  * @summary Get All Program Runs
6991
6984
  * @param {string} cell Unique identifier addressing a cell in all API calls.
6992
6985
  * @param {string} [state]
@@ -6994,8 +6987,8 @@ export class ProgramOperatorApi extends BaseAPI {
6994
6987
  * @throws {RequiredError}
6995
6988
  * @memberof ProgramOperatorApi
6996
6989
  */
6997
- getAllProgramRuns(cell, state, options) {
6998
- return ProgramOperatorApiFp(this.configuration).getAllProgramRuns(cell, state, options).then((request) => request(this.axios, this.basePath));
6990
+ getAllProgramOperatorRuns(cell, state, options) {
6991
+ return ProgramOperatorApiFp(this.configuration).getAllProgramOperatorRuns(cell, state, options).then((request) => request(this.axios, this.basePath));
6999
6992
  }
7000
6993
  /**
7001
6994
  * <!-- 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 {
7009
7002
  return ProgramOperatorApiFp(this.configuration).getAllTriggers(cell, options).then((request) => request(this.axios, this.basePath));
7010
7003
  }
7011
7004
  /**
7012
- * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run.
7005
+ * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run.
7013
7006
  * @summary Get Program Run
7014
7007
  * @param {string} run
7015
7008
  * @param {string} cell Unique identifier addressing a cell in all API calls.
@@ -7017,8 +7010,8 @@ export class ProgramOperatorApi extends BaseAPI {
7017
7010
  * @throws {RequiredError}
7018
7011
  * @memberof ProgramOperatorApi
7019
7012
  */
7020
- getProgramRun(run, cell, options) {
7021
- return ProgramOperatorApiFp(this.configuration).getProgramRun(run, cell, options).then((request) => request(this.axios, this.basePath));
7013
+ getProgramOperatorRun(run, cell, options) {
7014
+ return ProgramOperatorApiFp(this.configuration).getProgramOperatorRun(run, cell, options).then((request) => request(this.axios, this.basePath));
7022
7015
  }
7023
7016
  /**
7024
7017
  * <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific trigger.