@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.
- package/package.json +1 -1
- package/v2/api.d.ts +242 -502
- package/v2/api.js +235 -242
- package/v2/api.js.map +1 -1
- package/v2/api.ts +332 -592
package/v2/api.ts
CHANGED
|
@@ -249,118 +249,6 @@ export interface App {
|
|
|
249
249
|
*/
|
|
250
250
|
'health_path'?: string;
|
|
251
251
|
}
|
|
252
|
-
/**
|
|
253
|
-
*
|
|
254
|
-
* @export
|
|
255
|
-
* @interface ArrayInput
|
|
256
|
-
*/
|
|
257
|
-
export interface ArrayInput {
|
|
258
|
-
/**
|
|
259
|
-
*
|
|
260
|
-
* @type {Array<ArrayInputArrayInner>}
|
|
261
|
-
* @memberof ArrayInput
|
|
262
|
-
*/
|
|
263
|
-
'array': Array<ArrayInputArrayInner>;
|
|
264
|
-
}
|
|
265
|
-
/**
|
|
266
|
-
*
|
|
267
|
-
* @export
|
|
268
|
-
* @interface ArrayInputArrayInner
|
|
269
|
-
*/
|
|
270
|
-
export interface ArrayInputArrayInner {
|
|
271
|
-
/**
|
|
272
|
-
*
|
|
273
|
-
* @type {Array<any>}
|
|
274
|
-
* @memberof ArrayInputArrayInner
|
|
275
|
-
*/
|
|
276
|
-
'pose': Array<any>;
|
|
277
|
-
/**
|
|
278
|
-
*
|
|
279
|
-
* @type {Array<any>}
|
|
280
|
-
* @memberof ArrayInputArrayInner
|
|
281
|
-
*/
|
|
282
|
-
'position': Array<any>;
|
|
283
|
-
/**
|
|
284
|
-
*
|
|
285
|
-
* @type {Array<any>}
|
|
286
|
-
* @memberof ArrayInputArrayInner
|
|
287
|
-
*/
|
|
288
|
-
'orientation': Array<any>;
|
|
289
|
-
/**
|
|
290
|
-
*
|
|
291
|
-
* @type {string}
|
|
292
|
-
* @memberof ArrayInputArrayInner
|
|
293
|
-
*/
|
|
294
|
-
'image': string;
|
|
295
|
-
/**
|
|
296
|
-
*
|
|
297
|
-
* @type {string}
|
|
298
|
-
* @memberof ArrayInputArrayInner
|
|
299
|
-
*/
|
|
300
|
-
'pointcloud': string;
|
|
301
|
-
/**
|
|
302
|
-
*
|
|
303
|
-
* @type {Array<ArrayInputArrayInner>}
|
|
304
|
-
* @memberof ArrayInputArrayInner
|
|
305
|
-
*/
|
|
306
|
-
'array': Array<ArrayInputArrayInner>;
|
|
307
|
-
}
|
|
308
|
-
/**
|
|
309
|
-
*
|
|
310
|
-
* @export
|
|
311
|
-
* @interface ArrayOutput
|
|
312
|
-
*/
|
|
313
|
-
export interface ArrayOutput {
|
|
314
|
-
/**
|
|
315
|
-
*
|
|
316
|
-
* @type {Array<ArrayOutputArrayInner>}
|
|
317
|
-
* @memberof ArrayOutput
|
|
318
|
-
*/
|
|
319
|
-
'array': Array<ArrayOutputArrayInner>;
|
|
320
|
-
}
|
|
321
|
-
/**
|
|
322
|
-
*
|
|
323
|
-
* @export
|
|
324
|
-
* @interface ArrayOutputArrayInner
|
|
325
|
-
*/
|
|
326
|
-
export interface ArrayOutputArrayInner {
|
|
327
|
-
/**
|
|
328
|
-
*
|
|
329
|
-
* @type {Array<any>}
|
|
330
|
-
* @memberof ArrayOutputArrayInner
|
|
331
|
-
*/
|
|
332
|
-
'pose': Array<any>;
|
|
333
|
-
/**
|
|
334
|
-
*
|
|
335
|
-
* @type {Array<any>}
|
|
336
|
-
* @memberof ArrayOutputArrayInner
|
|
337
|
-
*/
|
|
338
|
-
'position': Array<any>;
|
|
339
|
-
/**
|
|
340
|
-
*
|
|
341
|
-
* @type {Array<any>}
|
|
342
|
-
* @memberof ArrayOutputArrayInner
|
|
343
|
-
*/
|
|
344
|
-
'orientation': Array<any>;
|
|
345
|
-
/**
|
|
346
|
-
*
|
|
347
|
-
* @type {string}
|
|
348
|
-
* @memberof ArrayOutputArrayInner
|
|
349
|
-
*/
|
|
350
|
-
'image': string;
|
|
351
|
-
/**
|
|
352
|
-
*
|
|
353
|
-
* @type {string}
|
|
354
|
-
* @memberof ArrayOutputArrayInner
|
|
355
|
-
*/
|
|
356
|
-
'pointcloud': string;
|
|
357
|
-
/**
|
|
358
|
-
*
|
|
359
|
-
* @type {Array<ArrayOutputArrayInner>}
|
|
360
|
-
* @memberof ArrayOutputArrayInner
|
|
361
|
-
*/
|
|
362
|
-
'array': Array<ArrayOutputArrayInner>;
|
|
363
|
-
}
|
|
364
252
|
/**
|
|
365
253
|
* ## BEHAVIOR_AUTOMATIC This is the default behavior. The motion group instantly takes any commanded joint configuration as actual joint state. Configures the compliance of the virtual robot with the normal ControllerState cycle time. If set, the virtual robot will act like a physical one, e.g. with a cycle time of 8ms to respond to a new joint state command. ## BEHAVIOR_AUTOMATIC_NOT_COMPLY_WITH_CYCLETIME Configures the compliance of the virtual robot with the normal ControllerState cycle time. If set, the robot will respond as fast as possible, limited only by software execution speed. Because of that the execution of a movement requires less time than with BEHAVIOR_AUTOMATIC. ## BEHAVIOR_EXTERNAL_SOURCE The external client is the only source of actual joint state changes. This mode is used to enable third party software indicating the current joint state via [externalJointsStream](externalJointsStream).
|
|
366
254
|
* @export
|
|
@@ -594,19 +482,6 @@ export const Capsule2ShapeTypeEnum = {
|
|
|
594
482
|
|
|
595
483
|
export type Capsule2ShapeTypeEnum = typeof Capsule2ShapeTypeEnum[keyof typeof Capsule2ShapeTypeEnum];
|
|
596
484
|
|
|
597
|
-
/**
|
|
598
|
-
*
|
|
599
|
-
* @export
|
|
600
|
-
* @interface Capture
|
|
601
|
-
*/
|
|
602
|
-
export interface Capture {
|
|
603
|
-
/**
|
|
604
|
-
*
|
|
605
|
-
* @type {string}
|
|
606
|
-
* @memberof Capture
|
|
607
|
-
*/
|
|
608
|
-
'image': string;
|
|
609
|
-
}
|
|
610
485
|
/**
|
|
611
486
|
* To create a robot cell, only a valid name is required. Once created, a robot cell provides access to the Wandelbots NOVA foundation services. The configuration can be customized, e.g. robot controllers, also within apps.
|
|
612
487
|
* @export
|
|
@@ -638,25 +513,6 @@ export interface Cell {
|
|
|
638
513
|
*/
|
|
639
514
|
'apps'?: Array<App>;
|
|
640
515
|
}
|
|
641
|
-
/**
|
|
642
|
-
*
|
|
643
|
-
* @export
|
|
644
|
-
* @interface CodeWithArguments
|
|
645
|
-
*/
|
|
646
|
-
export interface CodeWithArguments {
|
|
647
|
-
/**
|
|
648
|
-
* Wandelscript code string which describes a Wandelscript Program as content/json.
|
|
649
|
-
* @type {string}
|
|
650
|
-
* @memberof CodeWithArguments
|
|
651
|
-
*/
|
|
652
|
-
'code': string;
|
|
653
|
-
/**
|
|
654
|
-
*
|
|
655
|
-
* @type {{ [key: string]: ArrayInputArrayInner; }}
|
|
656
|
-
* @memberof CodeWithArguments
|
|
657
|
-
*/
|
|
658
|
-
'initial_state'?: { [key: string]: ArrayInputArrayInner; } | null;
|
|
659
|
-
}
|
|
660
516
|
/**
|
|
661
517
|
* Defines a collider with a single shape. A collider is an object that is used for collision detection. It defines the `shape` that is attached with the offset of `pose` to a reference frame. Use colliders to: - Define the shape of a workpiece. The reference frame is the scene origin. - Define the shape of a link in a motion group. The reference frame is the link coordinate system. - Define the shape of a tool. The reference frame is the flange coordinate system.
|
|
662
518
|
* @export
|
|
@@ -1188,26 +1044,26 @@ export interface CoordinateSystems {
|
|
|
1188
1044
|
/**
|
|
1189
1045
|
*
|
|
1190
1046
|
* @export
|
|
1191
|
-
* @interface
|
|
1047
|
+
* @interface CreateProgramOperatorRun200Response
|
|
1192
1048
|
*/
|
|
1193
|
-
export interface
|
|
1049
|
+
export interface CreateProgramOperatorRun200Response {
|
|
1194
1050
|
/**
|
|
1195
1051
|
* The identifier of the program run for further inspection of the running program.
|
|
1196
1052
|
* @type {string}
|
|
1197
|
-
* @memberof
|
|
1053
|
+
* @memberof CreateProgramOperatorRun200Response
|
|
1198
1054
|
*/
|
|
1199
1055
|
'id'?: string;
|
|
1200
1056
|
}
|
|
1201
1057
|
/**
|
|
1202
1058
|
*
|
|
1203
1059
|
* @export
|
|
1204
|
-
* @interface
|
|
1060
|
+
* @interface CreateProgramOperatorRunRequest
|
|
1205
1061
|
*/
|
|
1206
|
-
export interface
|
|
1062
|
+
export interface CreateProgramOperatorRunRequest {
|
|
1207
1063
|
/**
|
|
1208
1064
|
* The identifier of the program stored in the program library.
|
|
1209
1065
|
* @type {string}
|
|
1210
|
-
* @memberof
|
|
1066
|
+
* @memberof CreateProgramOperatorRunRequest
|
|
1211
1067
|
*/
|
|
1212
1068
|
'program_id': string;
|
|
1213
1069
|
}
|
|
@@ -1434,31 +1290,6 @@ export type ExecuteTrajectoryRequest = InitializeMovementRequest | PauseMovement
|
|
|
1434
1290
|
*/
|
|
1435
1291
|
export type ExecuteTrajectoryResponse = InitializeMovementResponse | Movement | MovementError | PauseMovementResponse | PlaybackSpeedResponse | Standstill;
|
|
1436
1292
|
|
|
1437
|
-
/**
|
|
1438
|
-
* The ExecutionResult object contains the execution results of a robot. Arguments: motion_group_id: The unique identifier of the motion group motion_duration: The total execution duration of the motion group paths: The paths of the motion group as list of Path objects
|
|
1439
|
-
* @export
|
|
1440
|
-
* @interface ExecutionResult
|
|
1441
|
-
*/
|
|
1442
|
-
export interface ExecutionResult {
|
|
1443
|
-
/**
|
|
1444
|
-
*
|
|
1445
|
-
* @type {string}
|
|
1446
|
-
* @memberof ExecutionResult
|
|
1447
|
-
*/
|
|
1448
|
-
'motion_group_id': string;
|
|
1449
|
-
/**
|
|
1450
|
-
*
|
|
1451
|
-
* @type {number}
|
|
1452
|
-
* @memberof ExecutionResult
|
|
1453
|
-
*/
|
|
1454
|
-
'motion_duration': number;
|
|
1455
|
-
/**
|
|
1456
|
-
*
|
|
1457
|
-
* @type {Array<Path>}
|
|
1458
|
-
* @memberof ExecutionResult
|
|
1459
|
-
*/
|
|
1460
|
-
'paths': Array<Path>;
|
|
1461
|
-
}
|
|
1462
1293
|
/**
|
|
1463
1294
|
* A datapoint inside external joint stream.
|
|
1464
1295
|
* @export
|
|
@@ -1803,13 +1634,13 @@ export interface Geometry {
|
|
|
1803
1634
|
/**
|
|
1804
1635
|
*
|
|
1805
1636
|
* @export
|
|
1806
|
-
* @interface
|
|
1637
|
+
* @interface GetAllProgramOperatorRuns200Response
|
|
1807
1638
|
*/
|
|
1808
|
-
export interface
|
|
1639
|
+
export interface GetAllProgramOperatorRuns200Response {
|
|
1809
1640
|
/**
|
|
1810
1641
|
*
|
|
1811
1642
|
* @type {Array<ProgramRunObject>}
|
|
1812
|
-
* @memberof
|
|
1643
|
+
* @memberof GetAllProgramOperatorRuns200Response
|
|
1813
1644
|
*/
|
|
1814
1645
|
'program_runs'?: Array<ProgramRunObject>;
|
|
1815
1646
|
}
|
|
@@ -3969,19 +3800,6 @@ export const OrientationType = {
|
|
|
3969
3800
|
export type OrientationType = typeof OrientationType[keyof typeof OrientationType];
|
|
3970
3801
|
|
|
3971
3802
|
|
|
3972
|
-
/**
|
|
3973
|
-
*
|
|
3974
|
-
* @export
|
|
3975
|
-
* @interface Path
|
|
3976
|
-
*/
|
|
3977
|
-
export interface Path {
|
|
3978
|
-
/**
|
|
3979
|
-
*
|
|
3980
|
-
* @type {Array<RobotState>}
|
|
3981
|
-
* @memberof Path
|
|
3982
|
-
*/
|
|
3983
|
-
'poses'?: Array<RobotState>;
|
|
3984
|
-
}
|
|
3985
3803
|
/**
|
|
3986
3804
|
* A cartesian point-to-point is representing a joint point-to-point motion from start point to the indicated target pose. The target pose is a joint point-to-point given in cartesian space. The target joint configuration will be calculated to be in the same kinematic configuration as the start point is. If that is not possible, planning will fail.
|
|
3987
3805
|
* @export
|
|
@@ -4504,19 +4322,6 @@ export interface PlaybackSpeedResponsePlaybackSpeedResponse {
|
|
|
4504
4322
|
*/
|
|
4505
4323
|
'requested_value': number;
|
|
4506
4324
|
}
|
|
4507
|
-
/**
|
|
4508
|
-
*
|
|
4509
|
-
* @export
|
|
4510
|
-
* @interface PointCloud
|
|
4511
|
-
*/
|
|
4512
|
-
export interface PointCloud {
|
|
4513
|
-
/**
|
|
4514
|
-
*
|
|
4515
|
-
* @type {string}
|
|
4516
|
-
* @memberof PointCloud
|
|
4517
|
-
*/
|
|
4518
|
-
'pointcloud': string;
|
|
4519
|
-
}
|
|
4520
4325
|
/**
|
|
4521
4326
|
* Defines a pose in 3D space. A pose is a combination of a position and an orientation. The position is applied before the orientation.
|
|
4522
4327
|
* @export
|
|
@@ -4564,17 +4369,48 @@ export interface PoseInCoordinateSystem {
|
|
|
4564
4369
|
/**
|
|
4565
4370
|
*
|
|
4566
4371
|
* @export
|
|
4372
|
+
* @interface ProgramRequest
|
|
4373
|
+
*/
|
|
4374
|
+
export interface ProgramRequest {
|
|
4375
|
+
/**
|
|
4376
|
+
*
|
|
4377
|
+
* @type {string}
|
|
4378
|
+
* @memberof ProgramRequest
|
|
4379
|
+
*/
|
|
4380
|
+
'program'?: string;
|
|
4381
|
+
/**
|
|
4382
|
+
*
|
|
4383
|
+
* @type {string}
|
|
4384
|
+
* @memberof ProgramRequest
|
|
4385
|
+
*/
|
|
4386
|
+
'default_robot'?: string | null;
|
|
4387
|
+
/**
|
|
4388
|
+
*
|
|
4389
|
+
* @type {string}
|
|
4390
|
+
* @memberof ProgramRequest
|
|
4391
|
+
*/
|
|
4392
|
+
'default_tcp'?: string | null;
|
|
4393
|
+
/**
|
|
4394
|
+
* Initial arguments that are available within the program
|
|
4395
|
+
* @type {{ [key: string]: RunArgsValue; }}
|
|
4396
|
+
* @memberof ProgramRequest
|
|
4397
|
+
*/
|
|
4398
|
+
'run_args'?: { [key: string]: RunArgsValue; };
|
|
4399
|
+
}
|
|
4400
|
+
/**
|
|
4401
|
+
* Holds the state of a program run. Args: id: The unique id of the program run state: The state of the program run logs: The logs of the program run stdout: The stdout of the program run store: The store of the program run error: The error message of the program run, if any traceback: The traceback of the program run, if any start_time: The start time of the program run end_time: The end time of the program run execution_results: The robot execution results of the program run
|
|
4402
|
+
* @export
|
|
4567
4403
|
* @interface ProgramRun
|
|
4568
4404
|
*/
|
|
4569
4405
|
export interface ProgramRun {
|
|
4570
4406
|
/**
|
|
4571
|
-
*
|
|
4407
|
+
* Unique id of the program run
|
|
4572
4408
|
* @type {string}
|
|
4573
4409
|
* @memberof ProgramRun
|
|
4574
4410
|
*/
|
|
4575
4411
|
'id': string;
|
|
4576
4412
|
/**
|
|
4577
|
-
*
|
|
4413
|
+
* State of the program run
|
|
4578
4414
|
* @type {ProgramRunState}
|
|
4579
4415
|
* @memberof ProgramRun
|
|
4580
4416
|
*/
|
|
@@ -4584,15 +4420,15 @@ export interface ProgramRun {
|
|
|
4584
4420
|
* @type {string}
|
|
4585
4421
|
* @memberof ProgramRun
|
|
4586
4422
|
*/
|
|
4587
|
-
'logs'?: string;
|
|
4423
|
+
'logs'?: string | null;
|
|
4588
4424
|
/**
|
|
4589
4425
|
*
|
|
4590
4426
|
* @type {string}
|
|
4591
4427
|
* @memberof ProgramRun
|
|
4592
4428
|
*/
|
|
4593
|
-
'stdout'?: string;
|
|
4429
|
+
'stdout'?: string | null;
|
|
4594
4430
|
/**
|
|
4595
|
-
*
|
|
4431
|
+
* Stores runtime variables of the run
|
|
4596
4432
|
* @type {{ [key: string]: StoreValue; }}
|
|
4597
4433
|
* @memberof ProgramRun
|
|
4598
4434
|
*/
|
|
@@ -4622,11 +4458,11 @@ export interface ProgramRun {
|
|
|
4622
4458
|
*/
|
|
4623
4459
|
'end_time'?: number | null;
|
|
4624
4460
|
/**
|
|
4625
|
-
*
|
|
4626
|
-
* @type {Array<
|
|
4461
|
+
* Execution results of the program run
|
|
4462
|
+
* @type {Array<ProgramRunResult>}
|
|
4627
4463
|
* @memberof ProgramRun
|
|
4628
4464
|
*/
|
|
4629
|
-
'execution_results'?: Array<
|
|
4465
|
+
'execution_results'?: Array<ProgramRunResult>;
|
|
4630
4466
|
}
|
|
4631
4467
|
|
|
4632
4468
|
|
|
@@ -4676,99 +4512,66 @@ export interface ProgramRunObject {
|
|
|
4676
4512
|
/**
|
|
4677
4513
|
*
|
|
4678
4514
|
* @export
|
|
4679
|
-
* @
|
|
4515
|
+
* @interface ProgramRunReference
|
|
4680
4516
|
*/
|
|
4681
|
-
|
|
4682
|
-
export const ProgramRunState = {
|
|
4683
|
-
NotStarted: 'not started',
|
|
4684
|
-
Running: 'running',
|
|
4685
|
-
Completed: 'completed',
|
|
4686
|
-
Failed: 'failed',
|
|
4687
|
-
Stopped: 'stopped'
|
|
4688
|
-
} as const;
|
|
4689
|
-
|
|
4690
|
-
export type ProgramRunState = typeof ProgramRunState[keyof typeof ProgramRunState];
|
|
4691
|
-
|
|
4692
|
-
|
|
4693
|
-
/**
|
|
4694
|
-
*
|
|
4695
|
-
* @export
|
|
4696
|
-
* @interface ProgramRunnerReference
|
|
4697
|
-
*/
|
|
4698
|
-
export interface ProgramRunnerReference {
|
|
4517
|
+
export interface ProgramRunReference {
|
|
4699
4518
|
/**
|
|
4700
4519
|
*
|
|
4701
4520
|
* @type {string}
|
|
4702
|
-
* @memberof
|
|
4521
|
+
* @memberof ProgramRunReference
|
|
4703
4522
|
*/
|
|
4704
4523
|
'id': string;
|
|
4705
4524
|
/**
|
|
4706
4525
|
*
|
|
4707
4526
|
* @type {ProgramRunState}
|
|
4708
|
-
* @memberof
|
|
4527
|
+
* @memberof ProgramRunReference
|
|
4709
4528
|
*/
|
|
4710
4529
|
'state': ProgramRunState;
|
|
4711
4530
|
}
|
|
4712
4531
|
|
|
4713
4532
|
|
|
4714
4533
|
/**
|
|
4715
|
-
*
|
|
4534
|
+
* The ProgramRunResult object contains the execution results of a robot. Arguments: motion_group_id: The unique id of the motion group motion_duration: The total execution duration of the motion group paths: The paths of the motion group as list of Path objects
|
|
4716
4535
|
* @export
|
|
4717
|
-
* @interface
|
|
4536
|
+
* @interface ProgramRunResult
|
|
4718
4537
|
*/
|
|
4719
|
-
export interface
|
|
4538
|
+
export interface ProgramRunResult {
|
|
4720
4539
|
/**
|
|
4721
|
-
*
|
|
4722
|
-
* @type {
|
|
4723
|
-
* @memberof
|
|
4724
|
-
*/
|
|
4725
|
-
'position': Array<any>;
|
|
4726
|
-
/**
|
|
4727
|
-
*
|
|
4728
|
-
* @type {Array<any>}
|
|
4729
|
-
* @memberof PyjectoryDatatypesCorePose
|
|
4540
|
+
* Unique id of the motion group that was executed
|
|
4541
|
+
* @type {string}
|
|
4542
|
+
* @memberof ProgramRunResult
|
|
4730
4543
|
*/
|
|
4731
|
-
'
|
|
4732
|
-
}
|
|
4733
|
-
/**
|
|
4734
|
-
* Rotation vector, defined in [rx, ry, rz] with floating numbers. The rotation is represented in vector3 using an axis-angle representation: axis.normalized * angle (angle in radians). Must be defined for the first pose of a path. If not defined for the rest of the path, the previous orientation will be used.
|
|
4735
|
-
* @export
|
|
4736
|
-
* @interface PyjectoryDatatypesSerializerOrientation
|
|
4737
|
-
*/
|
|
4738
|
-
export interface PyjectoryDatatypesSerializerOrientation {
|
|
4544
|
+
'motion_group_id': string;
|
|
4739
4545
|
/**
|
|
4740
|
-
*
|
|
4741
|
-
* @type {
|
|
4742
|
-
* @memberof
|
|
4546
|
+
* Total execution duration of the motion group
|
|
4547
|
+
* @type {number}
|
|
4548
|
+
* @memberof ProgramRunResult
|
|
4743
4549
|
*/
|
|
4744
|
-
'
|
|
4745
|
-
}
|
|
4746
|
-
/**
|
|
4747
|
-
* Object\'s position and orientaton, defined in [x, y, z, rx, ry, rz]. x,y,z are defined in millimeters. rx,ry,rz are defined in radians.
|
|
4748
|
-
* @export
|
|
4749
|
-
* @interface PyjectoryDatatypesSerializerPose
|
|
4750
|
-
*/
|
|
4751
|
-
export interface PyjectoryDatatypesSerializerPose {
|
|
4550
|
+
'motion_duration': number;
|
|
4752
4551
|
/**
|
|
4753
|
-
*
|
|
4754
|
-
* @type {Array<
|
|
4755
|
-
* @memberof
|
|
4552
|
+
* Paths of the motion group as list of Path objects
|
|
4553
|
+
* @type {Array<Array<RobotState>>}
|
|
4554
|
+
* @memberof ProgramRunResult
|
|
4756
4555
|
*/
|
|
4757
|
-
'
|
|
4556
|
+
'paths': Array<Array<RobotState>>;
|
|
4758
4557
|
}
|
|
4759
4558
|
/**
|
|
4760
|
-
*
|
|
4559
|
+
*
|
|
4761
4560
|
* @export
|
|
4762
|
-
* @
|
|
4561
|
+
* @enum {string}
|
|
4763
4562
|
*/
|
|
4764
|
-
|
|
4765
|
-
|
|
4766
|
-
|
|
4767
|
-
|
|
4768
|
-
|
|
4769
|
-
|
|
4770
|
-
'
|
|
4771
|
-
}
|
|
4563
|
+
|
|
4564
|
+
export const ProgramRunState = {
|
|
4565
|
+
NotStarted: 'not started',
|
|
4566
|
+
Running: 'running',
|
|
4567
|
+
Completed: 'completed',
|
|
4568
|
+
Failed: 'failed',
|
|
4569
|
+
Stopped: 'stopped'
|
|
4570
|
+
} as const;
|
|
4571
|
+
|
|
4572
|
+
export type ProgramRunState = typeof ProgramRunState[keyof typeof ProgramRunState];
|
|
4573
|
+
|
|
4574
|
+
|
|
4772
4575
|
/**
|
|
4773
4576
|
* Defines an x-y plane with finite size.
|
|
4774
4577
|
* @export
|
|
@@ -4897,44 +4700,6 @@ export const ReleaseChannel = {
|
|
|
4897
4700
|
export type ReleaseChannel = typeof ReleaseChannel[keyof typeof ReleaseChannel];
|
|
4898
4701
|
|
|
4899
4702
|
|
|
4900
|
-
/**
|
|
4901
|
-
* Wandelscript code string which describes a Program as text/plain
|
|
4902
|
-
* @export
|
|
4903
|
-
* @interface Request
|
|
4904
|
-
*/
|
|
4905
|
-
export interface Request {
|
|
4906
|
-
/**
|
|
4907
|
-
* Wandelscript code string which describes a Wandelscript Program as content/json.
|
|
4908
|
-
* @type {string}
|
|
4909
|
-
* @memberof Request
|
|
4910
|
-
*/
|
|
4911
|
-
'code': string;
|
|
4912
|
-
/**
|
|
4913
|
-
*
|
|
4914
|
-
* @type {{ [key: string]: ArrayInputArrayInner; }}
|
|
4915
|
-
* @memberof Request
|
|
4916
|
-
*/
|
|
4917
|
-
'initial_state'?: { [key: string]: ArrayInputArrayInner; };
|
|
4918
|
-
}
|
|
4919
|
-
/**
|
|
4920
|
-
* Wandelscript code string which describes a program
|
|
4921
|
-
* @export
|
|
4922
|
-
* @interface Request1
|
|
4923
|
-
*/
|
|
4924
|
-
export interface Request1 {
|
|
4925
|
-
/**
|
|
4926
|
-
* Wandelscript code string which describes a Wandelscript Program as content/json.
|
|
4927
|
-
* @type {string}
|
|
4928
|
-
* @memberof Request1
|
|
4929
|
-
*/
|
|
4930
|
-
'code': string;
|
|
4931
|
-
/**
|
|
4932
|
-
*
|
|
4933
|
-
* @type {{ [key: string]: ArrayInputArrayInner; }}
|
|
4934
|
-
* @memberof Request1
|
|
4935
|
-
*/
|
|
4936
|
-
'initial_state'?: { [key: string]: ArrayInputArrayInner; };
|
|
4937
|
-
}
|
|
4938
4703
|
/**
|
|
4939
4704
|
* The configuration of a physical or virtual robot controller.
|
|
4940
4705
|
* @export
|
|
@@ -5032,10 +4797,10 @@ export interface RobotLinkGeometry {
|
|
|
5032
4797
|
export interface RobotState {
|
|
5033
4798
|
/**
|
|
5034
4799
|
*
|
|
5035
|
-
* @type {
|
|
4800
|
+
* @type {Pose}
|
|
5036
4801
|
* @memberof RobotState
|
|
5037
4802
|
*/
|
|
5038
|
-
'pose':
|
|
4803
|
+
'pose': Pose;
|
|
5039
4804
|
/**
|
|
5040
4805
|
*
|
|
5041
4806
|
* @type {Array<number>}
|
|
@@ -5112,6 +4877,13 @@ export interface RobotTcps {
|
|
|
5112
4877
|
*/
|
|
5113
4878
|
'tcps': Array<RobotTcp>;
|
|
5114
4879
|
}
|
|
4880
|
+
/**
|
|
4881
|
+
*
|
|
4882
|
+
* @export
|
|
4883
|
+
* @interface RunArgsValue
|
|
4884
|
+
*/
|
|
4885
|
+
export interface RunArgsValue {
|
|
4886
|
+
}
|
|
5115
4887
|
/**
|
|
5116
4888
|
* The safety configuration of a motion-group. Used for motion planning.
|
|
5117
4889
|
* @export
|
|
@@ -5656,41 +5428,17 @@ export interface StartOnIO {
|
|
|
5656
5428
|
*/
|
|
5657
5429
|
export interface StoreValue {
|
|
5658
5430
|
/**
|
|
5659
|
-
*
|
|
5660
|
-
* @type {Array<
|
|
5661
|
-
* @memberof StoreValue
|
|
5662
|
-
*/
|
|
5663
|
-
'pose': Array<any>;
|
|
5664
|
-
/**
|
|
5665
|
-
*
|
|
5666
|
-
* @type {Array<any>}
|
|
5667
|
-
* @memberof StoreValue
|
|
5668
|
-
*/
|
|
5669
|
-
'position': Array<any>;
|
|
5670
|
-
/**
|
|
5671
|
-
*
|
|
5672
|
-
* @type {Array<any>}
|
|
5673
|
-
* @memberof StoreValue
|
|
5674
|
-
*/
|
|
5675
|
-
'orientation': Array<any>;
|
|
5676
|
-
/**
|
|
5677
|
-
*
|
|
5678
|
-
* @type {string}
|
|
5679
|
-
* @memberof StoreValue
|
|
5680
|
-
*/
|
|
5681
|
-
'image': string;
|
|
5682
|
-
/**
|
|
5683
|
-
*
|
|
5684
|
-
* @type {string}
|
|
5431
|
+
* A three-dimensional vector [x, y, z] with double precision.
|
|
5432
|
+
* @type {Array<number>}
|
|
5685
5433
|
* @memberof StoreValue
|
|
5686
5434
|
*/
|
|
5687
|
-
'
|
|
5435
|
+
'position'?: Array<number>;
|
|
5688
5436
|
/**
|
|
5689
|
-
*
|
|
5690
|
-
* @type {Array<
|
|
5437
|
+
* Defines a rotation in 3D space. A three-dimensional Vector [rx, ry, rz] with double precision. Rotation is applied around the vector. The angle of rotation equals the length of the vector.
|
|
5438
|
+
* @type {Array<number>}
|
|
5691
5439
|
* @memberof StoreValue
|
|
5692
5440
|
*/
|
|
5693
|
-
'
|
|
5441
|
+
'orientation'?: Array<number>;
|
|
5694
5442
|
}
|
|
5695
5443
|
/**
|
|
5696
5444
|
* Representing a robot pose in operational space aware of a configured TCP.
|
|
@@ -12056,19 +11804,19 @@ export class MotionGroupKinematicsApi extends BaseAPI {
|
|
|
12056
11804
|
export const ProgramApiAxiosParamCreator = function (configuration?: Configuration) {
|
|
12057
11805
|
return {
|
|
12058
11806
|
/**
|
|
12059
|
-
* This endpoint accepts a program
|
|
12060
|
-
* @summary Create
|
|
11807
|
+
* 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.
|
|
11808
|
+
* @summary Create program run
|
|
12061
11809
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12062
|
-
* @param {
|
|
11810
|
+
* @param {ProgramRequest} programRequest
|
|
12063
11811
|
* @param {*} [options] Override http request option.
|
|
12064
11812
|
* @throws {RequiredError}
|
|
12065
11813
|
*/
|
|
12066
|
-
|
|
11814
|
+
createProgramRun: async (cell: string, programRequest: ProgramRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
12067
11815
|
// verify required parameter 'cell' is not null or undefined
|
|
12068
|
-
assertParamExists('
|
|
12069
|
-
// verify required parameter '
|
|
12070
|
-
assertParamExists('
|
|
12071
|
-
const localVarPath = `/cells/{cell}/programs/
|
|
11816
|
+
assertParamExists('createProgramRun', 'cell', cell)
|
|
11817
|
+
// verify required parameter 'programRequest' is not null or undefined
|
|
11818
|
+
assertParamExists('createProgramRun', 'programRequest', programRequest)
|
|
11819
|
+
const localVarPath = `/cells/{cell}/programs/runs`
|
|
12072
11820
|
.replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
|
|
12073
11821
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
12074
11822
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
@@ -12091,12 +11839,12 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
|
|
|
12091
11839
|
|
|
12092
11840
|
|
|
12093
11841
|
|
|
12094
|
-
localVarHeaderParameter['Content-Type'] = '
|
|
11842
|
+
localVarHeaderParameter['Content-Type'] = 'application/json';
|
|
12095
11843
|
|
|
12096
11844
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
12097
11845
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
12098
11846
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
12099
|
-
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
11847
|
+
localVarRequestOptions.data = serializeDataIfNeeded(programRequest, localVarRequestOptions, configuration)
|
|
12100
11848
|
|
|
12101
11849
|
return {
|
|
12102
11850
|
url: toPathString(localVarUrlObj),
|
|
@@ -12104,18 +11852,18 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
|
|
|
12104
11852
|
};
|
|
12105
11853
|
},
|
|
12106
11854
|
/**
|
|
12107
|
-
* Execute a program
|
|
12108
|
-
* @summary Execute
|
|
11855
|
+
* 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.
|
|
11856
|
+
* @summary Execute program
|
|
12109
11857
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12110
|
-
* @param {
|
|
11858
|
+
* @param {ProgramRequest} programRequest
|
|
12111
11859
|
* @param {*} [options] Override http request option.
|
|
12112
11860
|
* @throws {RequiredError}
|
|
12113
11861
|
*/
|
|
12114
|
-
executeProgram: async (cell: string,
|
|
11862
|
+
executeProgram: async (cell: string, programRequest: ProgramRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
12115
11863
|
// verify required parameter 'cell' is not null or undefined
|
|
12116
11864
|
assertParamExists('executeProgram', 'cell', cell)
|
|
12117
|
-
// verify required parameter '
|
|
12118
|
-
assertParamExists('executeProgram', '
|
|
11865
|
+
// verify required parameter 'programRequest' is not null or undefined
|
|
11866
|
+
assertParamExists('executeProgram', 'programRequest', programRequest)
|
|
12119
11867
|
const localVarPath = `/cells/{cell}/programs/execute`
|
|
12120
11868
|
.replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
|
|
12121
11869
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
@@ -12144,7 +11892,7 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
|
|
|
12144
11892
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
12145
11893
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
12146
11894
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
12147
|
-
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
11895
|
+
localVarRequestOptions.data = serializeDataIfNeeded(programRequest, localVarRequestOptions, configuration)
|
|
12148
11896
|
|
|
12149
11897
|
return {
|
|
12150
11898
|
url: toPathString(localVarUrlObj),
|
|
@@ -12152,21 +11900,21 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
|
|
|
12152
11900
|
};
|
|
12153
11901
|
},
|
|
12154
11902
|
/**
|
|
12155
|
-
* Returns information about a program currently executed.
|
|
12156
|
-
* @summary Get
|
|
11903
|
+
* 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, ...
|
|
11904
|
+
* @summary Get program run
|
|
12157
11905
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12158
|
-
* @param {string}
|
|
11906
|
+
* @param {string} run
|
|
12159
11907
|
* @param {*} [options] Override http request option.
|
|
12160
11908
|
* @throws {RequiredError}
|
|
12161
11909
|
*/
|
|
12162
|
-
|
|
11910
|
+
getProgramRun: async (cell: string, run: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
12163
11911
|
// verify required parameter 'cell' is not null or undefined
|
|
12164
|
-
assertParamExists('
|
|
12165
|
-
// verify required parameter '
|
|
12166
|
-
assertParamExists('
|
|
12167
|
-
const localVarPath = `/cells/{cell}/programs/
|
|
11912
|
+
assertParamExists('getProgramRun', 'cell', cell)
|
|
11913
|
+
// verify required parameter 'run' is not null or undefined
|
|
11914
|
+
assertParamExists('getProgramRun', 'run', run)
|
|
11915
|
+
const localVarPath = `/cells/{cell}/programs/runs/{run}`
|
|
12168
11916
|
.replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
|
|
12169
|
-
.replace(`{${"
|
|
11917
|
+
.replace(`{${"run"}}`, encodeURIComponent(String(run)));
|
|
12170
11918
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
12171
11919
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
12172
11920
|
let baseOptions;
|
|
@@ -12198,16 +11946,16 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
|
|
|
12198
11946
|
};
|
|
12199
11947
|
},
|
|
12200
11948
|
/**
|
|
12201
|
-
* Get details about all existing
|
|
12202
|
-
* @summary List
|
|
11949
|
+
* Get details about all existing runs
|
|
11950
|
+
* @summary List programs
|
|
12203
11951
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12204
11952
|
* @param {*} [options] Override http request option.
|
|
12205
11953
|
* @throws {RequiredError}
|
|
12206
11954
|
*/
|
|
12207
|
-
|
|
11955
|
+
getProgramRuns: async (cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
12208
11956
|
// verify required parameter 'cell' is not null or undefined
|
|
12209
|
-
assertParamExists('
|
|
12210
|
-
const localVarPath = `/cells/{cell}/programs/
|
|
11957
|
+
assertParamExists('getProgramRuns', 'cell', cell)
|
|
11958
|
+
const localVarPath = `/cells/{cell}/programs/runs`
|
|
12211
11959
|
.replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
|
|
12212
11960
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
12213
11961
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
@@ -12240,19 +11988,19 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
|
|
|
12240
11988
|
};
|
|
12241
11989
|
},
|
|
12242
11990
|
/**
|
|
12243
|
-
*
|
|
12244
|
-
* @summary
|
|
11991
|
+
* Simulate a program given as text/plain
|
|
11992
|
+
* @summary Simulate program
|
|
12245
11993
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12246
|
-
* @param {
|
|
11994
|
+
* @param {ProgramRequest} programRequest
|
|
12247
11995
|
* @param {*} [options] Override http request option.
|
|
12248
11996
|
* @throws {RequiredError}
|
|
12249
11997
|
*/
|
|
12250
|
-
|
|
11998
|
+
simulateProgram: async (cell: string, programRequest: ProgramRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
12251
11999
|
// verify required parameter 'cell' is not null or undefined
|
|
12252
|
-
assertParamExists('
|
|
12253
|
-
// verify required parameter '
|
|
12254
|
-
assertParamExists('
|
|
12255
|
-
const localVarPath = `/cells/{cell}/programs/
|
|
12000
|
+
assertParamExists('simulateProgram', 'cell', cell)
|
|
12001
|
+
// verify required parameter 'programRequest' is not null or undefined
|
|
12002
|
+
assertParamExists('simulateProgram', 'programRequest', programRequest)
|
|
12003
|
+
const localVarPath = `/cells/{cell}/programs/simulate`
|
|
12256
12004
|
.replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
|
|
12257
12005
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
12258
12006
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
@@ -12275,12 +12023,12 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
|
|
|
12275
12023
|
|
|
12276
12024
|
|
|
12277
12025
|
|
|
12278
|
-
localVarHeaderParameter['Content-Type'] = '
|
|
12026
|
+
localVarHeaderParameter['Content-Type'] = 'application/json';
|
|
12279
12027
|
|
|
12280
12028
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
12281
12029
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
12282
12030
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
12283
|
-
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
12031
|
+
localVarRequestOptions.data = serializeDataIfNeeded(programRequest, localVarRequestOptions, configuration)
|
|
12284
12032
|
|
|
12285
12033
|
return {
|
|
12286
12034
|
url: toPathString(localVarUrlObj),
|
|
@@ -12288,20 +12036,16 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
|
|
|
12288
12036
|
};
|
|
12289
12037
|
},
|
|
12290
12038
|
/**
|
|
12291
|
-
*
|
|
12292
|
-
* @summary
|
|
12039
|
+
* Stop all runs
|
|
12040
|
+
* @summary Stop all programs
|
|
12293
12041
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12294
|
-
* @param {Request} request
|
|
12295
|
-
* @param {string} [identifier]
|
|
12296
12042
|
* @param {*} [options] Override http request option.
|
|
12297
12043
|
* @throws {RequiredError}
|
|
12298
12044
|
*/
|
|
12299
|
-
|
|
12045
|
+
stopAllPrograms: async (cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
12300
12046
|
// verify required parameter 'cell' is not null or undefined
|
|
12301
|
-
assertParamExists('
|
|
12302
|
-
|
|
12303
|
-
assertParamExists('planProgram', 'request', request)
|
|
12304
|
-
const localVarPath = `/cells/{cell}/programs/plan`
|
|
12047
|
+
assertParamExists('stopAllPrograms', 'cell', cell)
|
|
12048
|
+
const localVarPath = `/cells/{cell}/programs/runs/stop`
|
|
12305
12049
|
.replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
|
|
12306
12050
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
12307
12051
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
@@ -12322,18 +12066,11 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
|
|
|
12322
12066
|
// http bearer authentication required
|
|
12323
12067
|
await setBearerAuthToObject(localVarHeaderParameter, configuration)
|
|
12324
12068
|
|
|
12325
|
-
if (identifier !== undefined) {
|
|
12326
|
-
localVarQueryParameter['identifier'] = identifier;
|
|
12327
|
-
}
|
|
12328
|
-
|
|
12329
12069
|
|
|
12330
12070
|
|
|
12331
|
-
localVarHeaderParameter['Content-Type'] = 'text/plain';
|
|
12332
|
-
|
|
12333
12071
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
12334
12072
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
12335
12073
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
12336
|
-
localVarRequestOptions.data = serializeDataIfNeeded(request, localVarRequestOptions, configuration)
|
|
12337
12074
|
|
|
12338
12075
|
return {
|
|
12339
12076
|
url: toPathString(localVarUrlObj),
|
|
@@ -12341,17 +12078,21 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
|
|
|
12341
12078
|
};
|
|
12342
12079
|
},
|
|
12343
12080
|
/**
|
|
12344
|
-
* Stop
|
|
12345
|
-
* @summary Stop
|
|
12081
|
+
* Stop a specific program run.
|
|
12082
|
+
* @summary Stop program run
|
|
12346
12083
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12084
|
+
* @param {string} run
|
|
12347
12085
|
* @param {*} [options] Override http request option.
|
|
12348
12086
|
* @throws {RequiredError}
|
|
12349
12087
|
*/
|
|
12350
|
-
|
|
12088
|
+
stopProgramRun: async (cell: string, run: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
12351
12089
|
// verify required parameter 'cell' is not null or undefined
|
|
12352
|
-
assertParamExists('
|
|
12353
|
-
|
|
12354
|
-
|
|
12090
|
+
assertParamExists('stopProgramRun', 'cell', cell)
|
|
12091
|
+
// verify required parameter 'run' is not null or undefined
|
|
12092
|
+
assertParamExists('stopProgramRun', 'run', run)
|
|
12093
|
+
const localVarPath = `/cells/{cell}/programs/runs/{run}/stop`
|
|
12094
|
+
.replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
|
|
12095
|
+
.replace(`{${"run"}}`, encodeURIComponent(String(run)));
|
|
12355
12096
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
12356
12097
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
12357
12098
|
let baseOptions;
|
|
@@ -12383,21 +12124,20 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
|
|
|
12383
12124
|
};
|
|
12384
12125
|
},
|
|
12385
12126
|
/**
|
|
12386
|
-
*
|
|
12387
|
-
* @summary
|
|
12127
|
+
* Validate a program
|
|
12128
|
+
* @summary Validate program
|
|
12388
12129
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12389
|
-
* @param {
|
|
12130
|
+
* @param {ProgramRequest} programRequest
|
|
12390
12131
|
* @param {*} [options] Override http request option.
|
|
12391
12132
|
* @throws {RequiredError}
|
|
12392
12133
|
*/
|
|
12393
|
-
|
|
12134
|
+
validateProgram: async (cell: string, programRequest: ProgramRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
12394
12135
|
// verify required parameter 'cell' is not null or undefined
|
|
12395
|
-
assertParamExists('
|
|
12396
|
-
// verify required parameter '
|
|
12397
|
-
assertParamExists('
|
|
12398
|
-
const localVarPath = `/cells/{cell}/programs/
|
|
12399
|
-
.replace(`{${"cell"}}`, encodeURIComponent(String(cell)))
|
|
12400
|
-
.replace(`{${"runner"}}`, encodeURIComponent(String(runner)));
|
|
12136
|
+
assertParamExists('validateProgram', 'cell', cell)
|
|
12137
|
+
// verify required parameter 'programRequest' is not null or undefined
|
|
12138
|
+
assertParamExists('validateProgram', 'programRequest', programRequest)
|
|
12139
|
+
const localVarPath = `/cells/{cell}/programs/validate`
|
|
12140
|
+
.replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
|
|
12401
12141
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
12402
12142
|
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
12403
12143
|
let baseOptions;
|
|
@@ -12419,9 +12159,12 @@ export const ProgramApiAxiosParamCreator = function (configuration?: Configurati
|
|
|
12419
12159
|
|
|
12420
12160
|
|
|
12421
12161
|
|
|
12162
|
+
localVarHeaderParameter['Content-Type'] = 'application/json';
|
|
12163
|
+
|
|
12422
12164
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
12423
12165
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
12424
12166
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
12167
|
+
localVarRequestOptions.data = serializeDataIfNeeded(programRequest, localVarRequestOptions, configuration)
|
|
12425
12168
|
|
|
12426
12169
|
return {
|
|
12427
12170
|
url: toPathString(localVarUrlObj),
|
|
@@ -12439,114 +12182,113 @@ export const ProgramApiFp = function(configuration?: Configuration) {
|
|
|
12439
12182
|
const localVarAxiosParamCreator = ProgramApiAxiosParamCreator(configuration)
|
|
12440
12183
|
return {
|
|
12441
12184
|
/**
|
|
12442
|
-
* This endpoint accepts a program
|
|
12443
|
-
* @summary Create
|
|
12185
|
+
* 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.
|
|
12186
|
+
* @summary Create program run
|
|
12444
12187
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12445
|
-
* @param {
|
|
12188
|
+
* @param {ProgramRequest} programRequest
|
|
12446
12189
|
* @param {*} [options] Override http request option.
|
|
12447
12190
|
* @throws {RequiredError}
|
|
12448
12191
|
*/
|
|
12449
|
-
async
|
|
12450
|
-
const localVarAxiosArgs = await localVarAxiosParamCreator.
|
|
12192
|
+
async createProgramRun(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRunReference>> {
|
|
12193
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.createProgramRun(cell, programRequest, options);
|
|
12451
12194
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
12452
|
-
const localVarOperationServerBasePath = operationServerMap['ProgramApi.
|
|
12195
|
+
const localVarOperationServerBasePath = operationServerMap['ProgramApi.createProgramRun']?.[localVarOperationServerIndex]?.url;
|
|
12453
12196
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
12454
12197
|
},
|
|
12455
12198
|
/**
|
|
12456
|
-
* Execute a program
|
|
12457
|
-
* @summary Execute
|
|
12199
|
+
* 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.
|
|
12200
|
+
* @summary Execute program
|
|
12458
12201
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12459
|
-
* @param {
|
|
12202
|
+
* @param {ProgramRequest} programRequest
|
|
12460
12203
|
* @param {*} [options] Override http request option.
|
|
12461
12204
|
* @throws {RequiredError}
|
|
12462
12205
|
*/
|
|
12463
|
-
async executeProgram(cell: string,
|
|
12464
|
-
const localVarAxiosArgs = await localVarAxiosParamCreator.executeProgram(cell,
|
|
12206
|
+
async executeProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRun>> {
|
|
12207
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.executeProgram(cell, programRequest, options);
|
|
12465
12208
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
12466
12209
|
const localVarOperationServerBasePath = operationServerMap['ProgramApi.executeProgram']?.[localVarOperationServerIndex]?.url;
|
|
12467
12210
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
12468
12211
|
},
|
|
12469
12212
|
/**
|
|
12470
|
-
* Returns information about a program currently executed.
|
|
12471
|
-
* @summary Get
|
|
12213
|
+
* 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, ...
|
|
12214
|
+
* @summary Get program run
|
|
12472
12215
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12473
|
-
* @param {string}
|
|
12216
|
+
* @param {string} run
|
|
12474
12217
|
* @param {*} [options] Override http request option.
|
|
12475
12218
|
* @throws {RequiredError}
|
|
12476
12219
|
*/
|
|
12477
|
-
async
|
|
12478
|
-
const localVarAxiosArgs = await localVarAxiosParamCreator.
|
|
12220
|
+
async getProgramRun(cell: string, run: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRun>> {
|
|
12221
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.getProgramRun(cell, run, options);
|
|
12479
12222
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
12480
|
-
const localVarOperationServerBasePath = operationServerMap['ProgramApi.
|
|
12223
|
+
const localVarOperationServerBasePath = operationServerMap['ProgramApi.getProgramRun']?.[localVarOperationServerIndex]?.url;
|
|
12481
12224
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
12482
12225
|
},
|
|
12483
12226
|
/**
|
|
12484
|
-
* Get details about all existing
|
|
12485
|
-
* @summary List
|
|
12227
|
+
* Get details about all existing runs
|
|
12228
|
+
* @summary List programs
|
|
12486
12229
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12487
12230
|
* @param {*} [options] Override http request option.
|
|
12488
12231
|
* @throws {RequiredError}
|
|
12489
12232
|
*/
|
|
12490
|
-
async
|
|
12491
|
-
const localVarAxiosArgs = await localVarAxiosParamCreator.
|
|
12233
|
+
async getProgramRuns(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<ProgramRunReference>>> {
|
|
12234
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.getProgramRuns(cell, options);
|
|
12492
12235
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
12493
|
-
const localVarOperationServerBasePath = operationServerMap['ProgramApi.
|
|
12236
|
+
const localVarOperationServerBasePath = operationServerMap['ProgramApi.getProgramRuns']?.[localVarOperationServerIndex]?.url;
|
|
12494
12237
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
12495
12238
|
},
|
|
12496
12239
|
/**
|
|
12497
|
-
*
|
|
12498
|
-
* @summary
|
|
12240
|
+
* Simulate a program given as text/plain
|
|
12241
|
+
* @summary Simulate program
|
|
12499
12242
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12500
|
-
* @param {
|
|
12243
|
+
* @param {ProgramRequest} programRequest
|
|
12501
12244
|
* @param {*} [options] Override http request option.
|
|
12502
12245
|
* @throws {RequiredError}
|
|
12503
12246
|
*/
|
|
12504
|
-
async
|
|
12505
|
-
const localVarAxiosArgs = await localVarAxiosParamCreator.
|
|
12247
|
+
async simulateProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRun>> {
|
|
12248
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.simulateProgram(cell, programRequest, options);
|
|
12506
12249
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
12507
|
-
const localVarOperationServerBasePath = operationServerMap['ProgramApi.
|
|
12250
|
+
const localVarOperationServerBasePath = operationServerMap['ProgramApi.simulateProgram']?.[localVarOperationServerIndex]?.url;
|
|
12508
12251
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
12509
12252
|
},
|
|
12510
12253
|
/**
|
|
12511
|
-
*
|
|
12512
|
-
* @summary
|
|
12254
|
+
* Stop all runs
|
|
12255
|
+
* @summary Stop all programs
|
|
12513
12256
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12514
|
-
* @param {Request} request
|
|
12515
|
-
* @param {string} [identifier]
|
|
12516
12257
|
* @param {*} [options] Override http request option.
|
|
12517
12258
|
* @throws {RequiredError}
|
|
12518
12259
|
*/
|
|
12519
|
-
async
|
|
12520
|
-
const localVarAxiosArgs = await localVarAxiosParamCreator.
|
|
12260
|
+
async stopAllPrograms(cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<any>> {
|
|
12261
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.stopAllPrograms(cell, options);
|
|
12521
12262
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
12522
|
-
const localVarOperationServerBasePath = operationServerMap['ProgramApi.
|
|
12263
|
+
const localVarOperationServerBasePath = operationServerMap['ProgramApi.stopAllPrograms']?.[localVarOperationServerIndex]?.url;
|
|
12523
12264
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
12524
12265
|
},
|
|
12525
12266
|
/**
|
|
12526
|
-
* Stop
|
|
12527
|
-
* @summary Stop
|
|
12267
|
+
* Stop a specific program run.
|
|
12268
|
+
* @summary Stop program run
|
|
12528
12269
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12270
|
+
* @param {string} run
|
|
12529
12271
|
* @param {*} [options] Override http request option.
|
|
12530
12272
|
* @throws {RequiredError}
|
|
12531
12273
|
*/
|
|
12532
|
-
async
|
|
12533
|
-
const localVarAxiosArgs = await localVarAxiosParamCreator.
|
|
12274
|
+
async stopProgramRun(cell: string, run: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
|
|
12275
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.stopProgramRun(cell, run, options);
|
|
12534
12276
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
12535
|
-
const localVarOperationServerBasePath = operationServerMap['ProgramApi.
|
|
12277
|
+
const localVarOperationServerBasePath = operationServerMap['ProgramApi.stopProgramRun']?.[localVarOperationServerIndex]?.url;
|
|
12536
12278
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
12537
12279
|
},
|
|
12538
12280
|
/**
|
|
12539
|
-
*
|
|
12540
|
-
* @summary
|
|
12281
|
+
* Validate a program
|
|
12282
|
+
* @summary Validate program
|
|
12541
12283
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12542
|
-
* @param {
|
|
12284
|
+
* @param {ProgramRequest} programRequest
|
|
12543
12285
|
* @param {*} [options] Override http request option.
|
|
12544
12286
|
* @throws {RequiredError}
|
|
12545
12287
|
*/
|
|
12546
|
-
async
|
|
12547
|
-
const localVarAxiosArgs = await localVarAxiosParamCreator.
|
|
12288
|
+
async validateProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
|
|
12289
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.validateProgram(cell, programRequest, options);
|
|
12548
12290
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
12549
|
-
const localVarOperationServerBasePath = operationServerMap['ProgramApi.
|
|
12291
|
+
const localVarOperationServerBasePath = operationServerMap['ProgramApi.validateProgram']?.[localVarOperationServerIndex]?.url;
|
|
12550
12292
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
12551
12293
|
},
|
|
12552
12294
|
}
|
|
@@ -12560,91 +12302,90 @@ export const ProgramApiFactory = function (configuration?: Configuration, basePa
|
|
|
12560
12302
|
const localVarFp = ProgramApiFp(configuration)
|
|
12561
12303
|
return {
|
|
12562
12304
|
/**
|
|
12563
|
-
* This endpoint accepts a program
|
|
12564
|
-
* @summary Create
|
|
12305
|
+
* 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.
|
|
12306
|
+
* @summary Create program run
|
|
12565
12307
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12566
|
-
* @param {
|
|
12308
|
+
* @param {ProgramRequest} programRequest
|
|
12567
12309
|
* @param {*} [options] Override http request option.
|
|
12568
12310
|
* @throws {RequiredError}
|
|
12569
12311
|
*/
|
|
12570
|
-
|
|
12571
|
-
return localVarFp.
|
|
12312
|
+
createProgramRun(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRunReference> {
|
|
12313
|
+
return localVarFp.createProgramRun(cell, programRequest, options).then((request) => request(axios, basePath));
|
|
12572
12314
|
},
|
|
12573
12315
|
/**
|
|
12574
|
-
* Execute a program
|
|
12575
|
-
* @summary Execute
|
|
12316
|
+
* 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.
|
|
12317
|
+
* @summary Execute program
|
|
12576
12318
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12577
|
-
* @param {
|
|
12319
|
+
* @param {ProgramRequest} programRequest
|
|
12578
12320
|
* @param {*} [options] Override http request option.
|
|
12579
12321
|
* @throws {RequiredError}
|
|
12580
12322
|
*/
|
|
12581
|
-
executeProgram(cell: string,
|
|
12582
|
-
return localVarFp.executeProgram(cell,
|
|
12323
|
+
executeProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRun> {
|
|
12324
|
+
return localVarFp.executeProgram(cell, programRequest, options).then((request) => request(axios, basePath));
|
|
12583
12325
|
},
|
|
12584
12326
|
/**
|
|
12585
|
-
* Returns information about a program currently executed.
|
|
12586
|
-
* @summary Get
|
|
12327
|
+
* 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, ...
|
|
12328
|
+
* @summary Get program run
|
|
12587
12329
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12588
|
-
* @param {string}
|
|
12330
|
+
* @param {string} run
|
|
12589
12331
|
* @param {*} [options] Override http request option.
|
|
12590
12332
|
* @throws {RequiredError}
|
|
12591
12333
|
*/
|
|
12592
|
-
|
|
12593
|
-
return localVarFp.
|
|
12334
|
+
getProgramRun(cell: string, run: string, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRun> {
|
|
12335
|
+
return localVarFp.getProgramRun(cell, run, options).then((request) => request(axios, basePath));
|
|
12594
12336
|
},
|
|
12595
12337
|
/**
|
|
12596
|
-
* Get details about all existing
|
|
12597
|
-
* @summary List
|
|
12338
|
+
* Get details about all existing runs
|
|
12339
|
+
* @summary List programs
|
|
12598
12340
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12599
12341
|
* @param {*} [options] Override http request option.
|
|
12600
12342
|
* @throws {RequiredError}
|
|
12601
12343
|
*/
|
|
12602
|
-
|
|
12603
|
-
return localVarFp.
|
|
12344
|
+
getProgramRuns(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<Array<ProgramRunReference>> {
|
|
12345
|
+
return localVarFp.getProgramRuns(cell, options).then((request) => request(axios, basePath));
|
|
12604
12346
|
},
|
|
12605
12347
|
/**
|
|
12606
|
-
*
|
|
12607
|
-
* @summary
|
|
12348
|
+
* Simulate a program given as text/plain
|
|
12349
|
+
* @summary Simulate program
|
|
12608
12350
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12609
|
-
* @param {
|
|
12351
|
+
* @param {ProgramRequest} programRequest
|
|
12610
12352
|
* @param {*} [options] Override http request option.
|
|
12611
12353
|
* @throws {RequiredError}
|
|
12612
12354
|
*/
|
|
12613
|
-
|
|
12614
|
-
return localVarFp.
|
|
12355
|
+
simulateProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRun> {
|
|
12356
|
+
return localVarFp.simulateProgram(cell, programRequest, options).then((request) => request(axios, basePath));
|
|
12615
12357
|
},
|
|
12616
12358
|
/**
|
|
12617
|
-
*
|
|
12618
|
-
* @summary
|
|
12359
|
+
* Stop all runs
|
|
12360
|
+
* @summary Stop all programs
|
|
12619
12361
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12620
|
-
* @param {Request} request
|
|
12621
|
-
* @param {string} [identifier]
|
|
12622
12362
|
* @param {*} [options] Override http request option.
|
|
12623
12363
|
* @throws {RequiredError}
|
|
12624
12364
|
*/
|
|
12625
|
-
|
|
12626
|
-
return localVarFp.
|
|
12365
|
+
stopAllPrograms(cell: string, options?: RawAxiosRequestConfig): AxiosPromise<any> {
|
|
12366
|
+
return localVarFp.stopAllPrograms(cell, options).then((request) => request(axios, basePath));
|
|
12627
12367
|
},
|
|
12628
12368
|
/**
|
|
12629
|
-
* Stop
|
|
12630
|
-
* @summary Stop
|
|
12369
|
+
* Stop a specific program run.
|
|
12370
|
+
* @summary Stop program run
|
|
12631
12371
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12372
|
+
* @param {string} run
|
|
12632
12373
|
* @param {*} [options] Override http request option.
|
|
12633
12374
|
* @throws {RequiredError}
|
|
12634
12375
|
*/
|
|
12635
|
-
|
|
12636
|
-
return localVarFp.
|
|
12376
|
+
stopProgramRun(cell: string, run: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
|
|
12377
|
+
return localVarFp.stopProgramRun(cell, run, options).then((request) => request(axios, basePath));
|
|
12637
12378
|
},
|
|
12638
12379
|
/**
|
|
12639
|
-
*
|
|
12640
|
-
* @summary
|
|
12380
|
+
* Validate a program
|
|
12381
|
+
* @summary Validate program
|
|
12641
12382
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12642
|
-
* @param {
|
|
12383
|
+
* @param {ProgramRequest} programRequest
|
|
12643
12384
|
* @param {*} [options] Override http request option.
|
|
12644
12385
|
* @throws {RequiredError}
|
|
12645
12386
|
*/
|
|
12646
|
-
|
|
12647
|
-
return localVarFp.
|
|
12387
|
+
validateProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig): AxiosPromise<void> {
|
|
12388
|
+
return localVarFp.validateProgram(cell, programRequest, options).then((request) => request(axios, basePath));
|
|
12648
12389
|
},
|
|
12649
12390
|
};
|
|
12650
12391
|
};
|
|
@@ -12657,106 +12398,105 @@ export const ProgramApiFactory = function (configuration?: Configuration, basePa
|
|
|
12657
12398
|
*/
|
|
12658
12399
|
export class ProgramApi extends BaseAPI {
|
|
12659
12400
|
/**
|
|
12660
|
-
* This endpoint accepts a program
|
|
12661
|
-
* @summary Create
|
|
12401
|
+
* 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.
|
|
12402
|
+
* @summary Create program run
|
|
12662
12403
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12663
|
-
* @param {
|
|
12404
|
+
* @param {ProgramRequest} programRequest
|
|
12664
12405
|
* @param {*} [options] Override http request option.
|
|
12665
12406
|
* @throws {RequiredError}
|
|
12666
12407
|
* @memberof ProgramApi
|
|
12667
12408
|
*/
|
|
12668
|
-
public
|
|
12669
|
-
return ProgramApiFp(this.configuration).
|
|
12409
|
+
public createProgramRun(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig) {
|
|
12410
|
+
return ProgramApiFp(this.configuration).createProgramRun(cell, programRequest, options).then((request) => request(this.axios, this.basePath));
|
|
12670
12411
|
}
|
|
12671
12412
|
|
|
12672
12413
|
/**
|
|
12673
|
-
* Execute a program
|
|
12674
|
-
* @summary Execute
|
|
12414
|
+
* 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.
|
|
12415
|
+
* @summary Execute program
|
|
12675
12416
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12676
|
-
* @param {
|
|
12417
|
+
* @param {ProgramRequest} programRequest
|
|
12677
12418
|
* @param {*} [options] Override http request option.
|
|
12678
12419
|
* @throws {RequiredError}
|
|
12679
12420
|
* @memberof ProgramApi
|
|
12680
12421
|
*/
|
|
12681
|
-
public executeProgram(cell: string,
|
|
12682
|
-
return ProgramApiFp(this.configuration).executeProgram(cell,
|
|
12422
|
+
public executeProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig) {
|
|
12423
|
+
return ProgramApiFp(this.configuration).executeProgram(cell, programRequest, options).then((request) => request(this.axios, this.basePath));
|
|
12683
12424
|
}
|
|
12684
12425
|
|
|
12685
12426
|
/**
|
|
12686
|
-
* Returns information about a program currently executed.
|
|
12687
|
-
* @summary Get
|
|
12427
|
+
* 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, ...
|
|
12428
|
+
* @summary Get program run
|
|
12688
12429
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12689
|
-
* @param {string}
|
|
12430
|
+
* @param {string} run
|
|
12690
12431
|
* @param {*} [options] Override http request option.
|
|
12691
12432
|
* @throws {RequiredError}
|
|
12692
12433
|
* @memberof ProgramApi
|
|
12693
12434
|
*/
|
|
12694
|
-
public
|
|
12695
|
-
return ProgramApiFp(this.configuration).
|
|
12435
|
+
public getProgramRun(cell: string, run: string, options?: RawAxiosRequestConfig) {
|
|
12436
|
+
return ProgramApiFp(this.configuration).getProgramRun(cell, run, options).then((request) => request(this.axios, this.basePath));
|
|
12696
12437
|
}
|
|
12697
12438
|
|
|
12698
12439
|
/**
|
|
12699
|
-
* Get details about all existing
|
|
12700
|
-
* @summary List
|
|
12440
|
+
* Get details about all existing runs
|
|
12441
|
+
* @summary List programs
|
|
12701
12442
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12702
12443
|
* @param {*} [options] Override http request option.
|
|
12703
12444
|
* @throws {RequiredError}
|
|
12704
12445
|
* @memberof ProgramApi
|
|
12705
12446
|
*/
|
|
12706
|
-
public
|
|
12707
|
-
return ProgramApiFp(this.configuration).
|
|
12447
|
+
public getProgramRuns(cell: string, options?: RawAxiosRequestConfig) {
|
|
12448
|
+
return ProgramApiFp(this.configuration).getProgramRuns(cell, options).then((request) => request(this.axios, this.basePath));
|
|
12708
12449
|
}
|
|
12709
12450
|
|
|
12710
12451
|
/**
|
|
12711
|
-
*
|
|
12712
|
-
* @summary
|
|
12452
|
+
* Simulate a program given as text/plain
|
|
12453
|
+
* @summary Simulate program
|
|
12713
12454
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12714
|
-
* @param {
|
|
12455
|
+
* @param {ProgramRequest} programRequest
|
|
12715
12456
|
* @param {*} [options] Override http request option.
|
|
12716
12457
|
* @throws {RequiredError}
|
|
12717
12458
|
* @memberof ProgramApi
|
|
12718
12459
|
*/
|
|
12719
|
-
public
|
|
12720
|
-
return ProgramApiFp(this.configuration).
|
|
12460
|
+
public simulateProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig) {
|
|
12461
|
+
return ProgramApiFp(this.configuration).simulateProgram(cell, programRequest, options).then((request) => request(this.axios, this.basePath));
|
|
12721
12462
|
}
|
|
12722
12463
|
|
|
12723
12464
|
/**
|
|
12724
|
-
*
|
|
12725
|
-
* @summary
|
|
12465
|
+
* Stop all runs
|
|
12466
|
+
* @summary Stop all programs
|
|
12726
12467
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12727
|
-
* @param {Request} request
|
|
12728
|
-
* @param {string} [identifier]
|
|
12729
12468
|
* @param {*} [options] Override http request option.
|
|
12730
12469
|
* @throws {RequiredError}
|
|
12731
12470
|
* @memberof ProgramApi
|
|
12732
12471
|
*/
|
|
12733
|
-
public
|
|
12734
|
-
return ProgramApiFp(this.configuration).
|
|
12472
|
+
public stopAllPrograms(cell: string, options?: RawAxiosRequestConfig) {
|
|
12473
|
+
return ProgramApiFp(this.configuration).stopAllPrograms(cell, options).then((request) => request(this.axios, this.basePath));
|
|
12735
12474
|
}
|
|
12736
12475
|
|
|
12737
12476
|
/**
|
|
12738
|
-
* Stop
|
|
12739
|
-
* @summary Stop
|
|
12477
|
+
* Stop a specific program run.
|
|
12478
|
+
* @summary Stop program run
|
|
12740
12479
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12480
|
+
* @param {string} run
|
|
12741
12481
|
* @param {*} [options] Override http request option.
|
|
12742
12482
|
* @throws {RequiredError}
|
|
12743
12483
|
* @memberof ProgramApi
|
|
12744
12484
|
*/
|
|
12745
|
-
public
|
|
12746
|
-
return ProgramApiFp(this.configuration).
|
|
12485
|
+
public stopProgramRun(cell: string, run: string, options?: RawAxiosRequestConfig) {
|
|
12486
|
+
return ProgramApiFp(this.configuration).stopProgramRun(cell, run, options).then((request) => request(this.axios, this.basePath));
|
|
12747
12487
|
}
|
|
12748
12488
|
|
|
12749
12489
|
/**
|
|
12750
|
-
*
|
|
12751
|
-
* @summary
|
|
12490
|
+
* Validate a program
|
|
12491
|
+
* @summary Validate program
|
|
12752
12492
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12753
|
-
* @param {
|
|
12493
|
+
* @param {ProgramRequest} programRequest
|
|
12754
12494
|
* @param {*} [options] Override http request option.
|
|
12755
12495
|
* @throws {RequiredError}
|
|
12756
12496
|
* @memberof ProgramApi
|
|
12757
12497
|
*/
|
|
12758
|
-
public
|
|
12759
|
-
return ProgramApiFp(this.configuration).
|
|
12498
|
+
public validateProgram(cell: string, programRequest: ProgramRequest, options?: RawAxiosRequestConfig) {
|
|
12499
|
+
return ProgramApiFp(this.configuration).validateProgram(cell, programRequest, options).then((request) => request(this.axios, this.basePath));
|
|
12760
12500
|
}
|
|
12761
12501
|
}
|
|
12762
12502
|
|
|
@@ -12769,18 +12509,18 @@ export class ProgramApi extends BaseAPI {
|
|
|
12769
12509
|
export const ProgramOperatorApiAxiosParamCreator = function (configuration?: Configuration) {
|
|
12770
12510
|
return {
|
|
12771
12511
|
/**
|
|
12772
|
-
* <!-- theme: danger -->
|
|
12512
|
+
* <!-- 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.
|
|
12773
12513
|
* @summary Run Program from Library
|
|
12774
12514
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12775
|
-
* @param {
|
|
12515
|
+
* @param {CreateProgramOperatorRunRequest} createProgramOperatorRunRequest
|
|
12776
12516
|
* @param {*} [options] Override http request option.
|
|
12777
12517
|
* @throws {RequiredError}
|
|
12778
12518
|
*/
|
|
12779
|
-
|
|
12519
|
+
createProgramOperatorRun: async (cell: string, createProgramOperatorRunRequest: CreateProgramOperatorRunRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
12780
12520
|
// verify required parameter 'cell' is not null or undefined
|
|
12781
|
-
assertParamExists('
|
|
12782
|
-
// verify required parameter '
|
|
12783
|
-
assertParamExists('
|
|
12521
|
+
assertParamExists('createProgramOperatorRun', 'cell', cell)
|
|
12522
|
+
// verify required parameter 'createProgramOperatorRunRequest' is not null or undefined
|
|
12523
|
+
assertParamExists('createProgramOperatorRun', 'createProgramOperatorRunRequest', createProgramOperatorRunRequest)
|
|
12784
12524
|
const localVarPath = `/cells/{cell}/operator/programs/runs`
|
|
12785
12525
|
.replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
|
|
12786
12526
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
@@ -12809,7 +12549,7 @@ export const ProgramOperatorApiAxiosParamCreator = function (configuration?: Con
|
|
|
12809
12549
|
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
12810
12550
|
let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
12811
12551
|
localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
|
|
12812
|
-
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
12552
|
+
localVarRequestOptions.data = serializeDataIfNeeded(createProgramOperatorRunRequest, localVarRequestOptions, configuration)
|
|
12813
12553
|
|
|
12814
12554
|
return {
|
|
12815
12555
|
url: toPathString(localVarUrlObj),
|
|
@@ -12911,16 +12651,16 @@ export const ProgramOperatorApiAxiosParamCreator = function (configuration?: Con
|
|
|
12911
12651
|
};
|
|
12912
12652
|
},
|
|
12913
12653
|
/**
|
|
12914
|
-
* <!-- theme: danger -->
|
|
12654
|
+
* <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status.
|
|
12915
12655
|
* @summary Get All Program Runs
|
|
12916
12656
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
12917
12657
|
* @param {string} [state]
|
|
12918
12658
|
* @param {*} [options] Override http request option.
|
|
12919
12659
|
* @throws {RequiredError}
|
|
12920
12660
|
*/
|
|
12921
|
-
|
|
12661
|
+
getAllProgramOperatorRuns: async (cell: string, state?: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
12922
12662
|
// verify required parameter 'cell' is not null or undefined
|
|
12923
|
-
assertParamExists('
|
|
12663
|
+
assertParamExists('getAllProgramOperatorRuns', 'cell', cell)
|
|
12924
12664
|
const localVarPath = `/cells/{cell}/operator/programs/runs`
|
|
12925
12665
|
.replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
|
|
12926
12666
|
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
@@ -13000,18 +12740,18 @@ export const ProgramOperatorApiAxiosParamCreator = function (configuration?: Con
|
|
|
13000
12740
|
};
|
|
13001
12741
|
},
|
|
13002
12742
|
/**
|
|
13003
|
-
* <!-- theme: danger -->
|
|
12743
|
+
* <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run.
|
|
13004
12744
|
* @summary Get Program Run
|
|
13005
12745
|
* @param {string} run
|
|
13006
12746
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
13007
12747
|
* @param {*} [options] Override http request option.
|
|
13008
12748
|
* @throws {RequiredError}
|
|
13009
12749
|
*/
|
|
13010
|
-
|
|
12750
|
+
getProgramOperatorRun: async (run: string, cell: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
|
|
13011
12751
|
// verify required parameter 'run' is not null or undefined
|
|
13012
|
-
assertParamExists('
|
|
12752
|
+
assertParamExists('getProgramOperatorRun', 'run', run)
|
|
13013
12753
|
// verify required parameter 'cell' is not null or undefined
|
|
13014
|
-
assertParamExists('
|
|
12754
|
+
assertParamExists('getProgramOperatorRun', 'cell', cell)
|
|
13015
12755
|
const localVarPath = `/cells/{cell}/operator/programs/runs/{run}`
|
|
13016
12756
|
.replace(`{${"run"}}`, encodeURIComponent(String(run)))
|
|
13017
12757
|
.replace(`{${"cell"}}`, encodeURIComponent(String(cell)));
|
|
@@ -13154,17 +12894,17 @@ export const ProgramOperatorApiFp = function(configuration?: Configuration) {
|
|
|
13154
12894
|
const localVarAxiosParamCreator = ProgramOperatorApiAxiosParamCreator(configuration)
|
|
13155
12895
|
return {
|
|
13156
12896
|
/**
|
|
13157
|
-
* <!-- theme: danger -->
|
|
12897
|
+
* <!-- 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.
|
|
13158
12898
|
* @summary Run Program from Library
|
|
13159
12899
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
13160
|
-
* @param {
|
|
12900
|
+
* @param {CreateProgramOperatorRunRequest} createProgramOperatorRunRequest
|
|
13161
12901
|
* @param {*} [options] Override http request option.
|
|
13162
12902
|
* @throws {RequiredError}
|
|
13163
12903
|
*/
|
|
13164
|
-
async
|
|
13165
|
-
const localVarAxiosArgs = await localVarAxiosParamCreator.
|
|
12904
|
+
async createProgramOperatorRun(cell: string, createProgramOperatorRunRequest: CreateProgramOperatorRunRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CreateProgramOperatorRun200Response>> {
|
|
12905
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.createProgramOperatorRun(cell, createProgramOperatorRunRequest, options);
|
|
13166
12906
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
13167
|
-
const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.
|
|
12907
|
+
const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.createProgramOperatorRun']?.[localVarOperationServerIndex]?.url;
|
|
13168
12908
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
13169
12909
|
},
|
|
13170
12910
|
/**
|
|
@@ -13196,17 +12936,17 @@ export const ProgramOperatorApiFp = function(configuration?: Configuration) {
|
|
|
13196
12936
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
13197
12937
|
},
|
|
13198
12938
|
/**
|
|
13199
|
-
* <!-- theme: danger -->
|
|
12939
|
+
* <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status.
|
|
13200
12940
|
* @summary Get All Program Runs
|
|
13201
12941
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
13202
12942
|
* @param {string} [state]
|
|
13203
12943
|
* @param {*} [options] Override http request option.
|
|
13204
12944
|
* @throws {RequiredError}
|
|
13205
12945
|
*/
|
|
13206
|
-
async
|
|
13207
|
-
const localVarAxiosArgs = await localVarAxiosParamCreator.
|
|
12946
|
+
async getAllProgramOperatorRuns(cell: string, state?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GetAllProgramOperatorRuns200Response>> {
|
|
12947
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.getAllProgramOperatorRuns(cell, state, options);
|
|
13208
12948
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
13209
|
-
const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.
|
|
12949
|
+
const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.getAllProgramOperatorRuns']?.[localVarOperationServerIndex]?.url;
|
|
13210
12950
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
13211
12951
|
},
|
|
13212
12952
|
/**
|
|
@@ -13223,17 +12963,17 @@ export const ProgramOperatorApiFp = function(configuration?: Configuration) {
|
|
|
13223
12963
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
13224
12964
|
},
|
|
13225
12965
|
/**
|
|
13226
|
-
* <!-- theme: danger -->
|
|
12966
|
+
* <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run.
|
|
13227
12967
|
* @summary Get Program Run
|
|
13228
12968
|
* @param {string} run
|
|
13229
12969
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
13230
12970
|
* @param {*} [options] Override http request option.
|
|
13231
12971
|
* @throws {RequiredError}
|
|
13232
12972
|
*/
|
|
13233
|
-
async
|
|
13234
|
-
const localVarAxiosArgs = await localVarAxiosParamCreator.
|
|
12973
|
+
async getProgramOperatorRun(run: string, cell: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProgramRunObject>> {
|
|
12974
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.getProgramOperatorRun(run, cell, options);
|
|
13235
12975
|
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
13236
|
-
const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.
|
|
12976
|
+
const localVarOperationServerBasePath = operationServerMap['ProgramOperatorApi.getProgramOperatorRun']?.[localVarOperationServerIndex]?.url;
|
|
13237
12977
|
return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
|
|
13238
12978
|
},
|
|
13239
12979
|
/**
|
|
@@ -13276,15 +13016,15 @@ export const ProgramOperatorApiFactory = function (configuration?: Configuration
|
|
|
13276
13016
|
const localVarFp = ProgramOperatorApiFp(configuration)
|
|
13277
13017
|
return {
|
|
13278
13018
|
/**
|
|
13279
|
-
* <!-- theme: danger -->
|
|
13019
|
+
* <!-- 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.
|
|
13280
13020
|
* @summary Run Program from Library
|
|
13281
13021
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
13282
|
-
* @param {
|
|
13022
|
+
* @param {CreateProgramOperatorRunRequest} createProgramOperatorRunRequest
|
|
13283
13023
|
* @param {*} [options] Override http request option.
|
|
13284
13024
|
* @throws {RequiredError}
|
|
13285
13025
|
*/
|
|
13286
|
-
|
|
13287
|
-
return localVarFp.
|
|
13026
|
+
createProgramOperatorRun(cell: string, createProgramOperatorRunRequest: CreateProgramOperatorRunRequest, options?: RawAxiosRequestConfig): AxiosPromise<CreateProgramOperatorRun200Response> {
|
|
13027
|
+
return localVarFp.createProgramOperatorRun(cell, createProgramOperatorRunRequest, options).then((request) => request(axios, basePath));
|
|
13288
13028
|
},
|
|
13289
13029
|
/**
|
|
13290
13030
|
* <!-- theme: danger --> > **Experimental** Creates a new trigger that automatically runs a program when certain conditions are met. Each trigger has a different configuration, and the configuration must be valid for the provided trigger type.
|
|
@@ -13309,15 +13049,15 @@ export const ProgramOperatorApiFactory = function (configuration?: Configuration
|
|
|
13309
13049
|
return localVarFp.deleteTrigger(trigger, cell, options).then((request) => request(axios, basePath));
|
|
13310
13050
|
},
|
|
13311
13051
|
/**
|
|
13312
|
-
* <!-- theme: danger -->
|
|
13052
|
+
* <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status.
|
|
13313
13053
|
* @summary Get All Program Runs
|
|
13314
13054
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
13315
13055
|
* @param {string} [state]
|
|
13316
13056
|
* @param {*} [options] Override http request option.
|
|
13317
13057
|
* @throws {RequiredError}
|
|
13318
13058
|
*/
|
|
13319
|
-
|
|
13320
|
-
return localVarFp.
|
|
13059
|
+
getAllProgramOperatorRuns(cell: string, state?: string, options?: RawAxiosRequestConfig): AxiosPromise<GetAllProgramOperatorRuns200Response> {
|
|
13060
|
+
return localVarFp.getAllProgramOperatorRuns(cell, state, options).then((request) => request(axios, basePath));
|
|
13321
13061
|
},
|
|
13322
13062
|
/**
|
|
13323
13063
|
* <!-- theme: danger --> > **Experimental** Returns all triggers in the system with the program runs caused by each trigger. You can use the program run id to get more details about a specific program run.
|
|
@@ -13330,15 +13070,15 @@ export const ProgramOperatorApiFactory = function (configuration?: Configuration
|
|
|
13330
13070
|
return localVarFp.getAllTriggers(cell, options).then((request) => request(axios, basePath));
|
|
13331
13071
|
},
|
|
13332
13072
|
/**
|
|
13333
|
-
* <!-- theme: danger -->
|
|
13073
|
+
* <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run.
|
|
13334
13074
|
* @summary Get Program Run
|
|
13335
13075
|
* @param {string} run
|
|
13336
13076
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
13337
13077
|
* @param {*} [options] Override http request option.
|
|
13338
13078
|
* @throws {RequiredError}
|
|
13339
13079
|
*/
|
|
13340
|
-
|
|
13341
|
-
return localVarFp.
|
|
13080
|
+
getProgramOperatorRun(run: string, cell: string, options?: RawAxiosRequestConfig): AxiosPromise<ProgramRunObject> {
|
|
13081
|
+
return localVarFp.getProgramOperatorRun(run, cell, options).then((request) => request(axios, basePath));
|
|
13342
13082
|
},
|
|
13343
13083
|
/**
|
|
13344
13084
|
* <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific trigger.
|
|
@@ -13374,16 +13114,16 @@ export const ProgramOperatorApiFactory = function (configuration?: Configuration
|
|
|
13374
13114
|
*/
|
|
13375
13115
|
export class ProgramOperatorApi extends BaseAPI {
|
|
13376
13116
|
/**
|
|
13377
|
-
* <!-- theme: danger -->
|
|
13117
|
+
* <!-- 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.
|
|
13378
13118
|
* @summary Run Program from Library
|
|
13379
13119
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
13380
|
-
* @param {
|
|
13120
|
+
* @param {CreateProgramOperatorRunRequest} createProgramOperatorRunRequest
|
|
13381
13121
|
* @param {*} [options] Override http request option.
|
|
13382
13122
|
* @throws {RequiredError}
|
|
13383
13123
|
* @memberof ProgramOperatorApi
|
|
13384
13124
|
*/
|
|
13385
|
-
public
|
|
13386
|
-
return ProgramOperatorApiFp(this.configuration).
|
|
13125
|
+
public createProgramOperatorRun(cell: string, createProgramOperatorRunRequest: CreateProgramOperatorRunRequest, options?: RawAxiosRequestConfig) {
|
|
13126
|
+
return ProgramOperatorApiFp(this.configuration).createProgramOperatorRun(cell, createProgramOperatorRunRequest, options).then((request) => request(this.axios, this.basePath));
|
|
13387
13127
|
}
|
|
13388
13128
|
|
|
13389
13129
|
/**
|
|
@@ -13413,7 +13153,7 @@ export class ProgramOperatorApi extends BaseAPI {
|
|
|
13413
13153
|
}
|
|
13414
13154
|
|
|
13415
13155
|
/**
|
|
13416
|
-
* <!-- theme: danger -->
|
|
13156
|
+
* <!-- theme: danger --> > **Experimental** Retrieves all program runs, including past and current executions. Use the optional `state` parameter to filter the results by their status.
|
|
13417
13157
|
* @summary Get All Program Runs
|
|
13418
13158
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
13419
13159
|
* @param {string} [state]
|
|
@@ -13421,8 +13161,8 @@ export class ProgramOperatorApi extends BaseAPI {
|
|
|
13421
13161
|
* @throws {RequiredError}
|
|
13422
13162
|
* @memberof ProgramOperatorApi
|
|
13423
13163
|
*/
|
|
13424
|
-
public
|
|
13425
|
-
return ProgramOperatorApiFp(this.configuration).
|
|
13164
|
+
public getAllProgramOperatorRuns(cell: string, state?: string, options?: RawAxiosRequestConfig) {
|
|
13165
|
+
return ProgramOperatorApiFp(this.configuration).getAllProgramOperatorRuns(cell, state, options).then((request) => request(this.axios, this.basePath));
|
|
13426
13166
|
}
|
|
13427
13167
|
|
|
13428
13168
|
/**
|
|
@@ -13438,7 +13178,7 @@ export class ProgramOperatorApi extends BaseAPI {
|
|
|
13438
13178
|
}
|
|
13439
13179
|
|
|
13440
13180
|
/**
|
|
13441
|
-
* <!-- theme: danger -->
|
|
13181
|
+
* <!-- theme: danger --> > **Experimental** Retrieves detailed information about a specific program run.
|
|
13442
13182
|
* @summary Get Program Run
|
|
13443
13183
|
* @param {string} run
|
|
13444
13184
|
* @param {string} cell Unique identifier addressing a cell in all API calls.
|
|
@@ -13446,8 +13186,8 @@ export class ProgramOperatorApi extends BaseAPI {
|
|
|
13446
13186
|
* @throws {RequiredError}
|
|
13447
13187
|
* @memberof ProgramOperatorApi
|
|
13448
13188
|
*/
|
|
13449
|
-
public
|
|
13450
|
-
return ProgramOperatorApiFp(this.configuration).
|
|
13189
|
+
public getProgramOperatorRun(run: string, cell: string, options?: RawAxiosRequestConfig) {
|
|
13190
|
+
return ProgramOperatorApiFp(this.configuration).getProgramOperatorRun(run, cell, options).then((request) => request(this.axios, this.basePath));
|
|
13451
13191
|
}
|
|
13452
13192
|
|
|
13453
13193
|
/**
|