rusoto_robomaker/
generated.rs

1// =================================================================
2//
3//                           * WARNING *
4//
5//                    This file is generated!
6//
7//  Changes made to this file will be overwritten. If changes are
8//  required to the generated code, the service_crategen project
9//  must be updated to generate the changes.
10//
11// =================================================================
12
13use std::error::Error;
14use std::fmt;
15
16use async_trait::async_trait;
17use rusoto_core::credential::ProvideAwsCredentials;
18use rusoto_core::region;
19use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
20use rusoto_core::{Client, RusotoError};
21
22use rusoto_core::param::{Params, ServiceParams};
23use rusoto_core::proto;
24use rusoto_core::signature::SignedRequest;
25#[allow(unused_imports)]
26use serde::{Deserialize, Serialize};
27use serde_json;
28#[derive(Clone, Debug, Default, PartialEq, Serialize)]
29#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
30pub struct BatchDescribeSimulationJobRequest {
31    /// <p>A list of Amazon Resource Names (ARNs) of simulation jobs to describe.</p>
32    #[serde(rename = "jobs")]
33    pub jobs: Vec<String>,
34}
35
36#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
37#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
38pub struct BatchDescribeSimulationJobResponse {
39    /// <p>A list of simulation jobs.</p>
40    #[serde(rename = "jobs")]
41    #[serde(skip_serializing_if = "Option::is_none")]
42    pub jobs: Option<Vec<SimulationJob>>,
43    /// <p>A list of unprocessed simulation job Amazon Resource Names (ARNs).</p>
44    #[serde(rename = "unprocessedJobs")]
45    #[serde(skip_serializing_if = "Option::is_none")]
46    pub unprocessed_jobs: Option<Vec<String>>,
47}
48
49/// <p>Information about the batch policy.</p>
50#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
51pub struct BatchPolicy {
52    /// <p>The number of active simulation jobs create as part of the batch that can be in an active state at the same time. </p> <p>Active states include: <code>Pending</code>,<code>Preparing</code>, <code>Running</code>, <code>Restarting</code>, <code>RunningFailed</code> and <code>Terminating</code>. All other states are terminal states. </p>
53    #[serde(rename = "maxConcurrency")]
54    #[serde(skip_serializing_if = "Option::is_none")]
55    pub max_concurrency: Option<i64>,
56    /// <p>The amount of time, in seconds, to wait for the batch to complete. </p> <p>If a batch times out, and there are pending requests that were failing due to an internal failure (like <code>InternalServiceError</code>), they will be moved to the failed list and the batch status will be <code>Failed</code>. If the pending requests were failing for any other reason, the failed pending requests will be moved to the failed list and the batch status will be <code>TimedOut</code>. </p>
57    #[serde(rename = "timeoutInSeconds")]
58    #[serde(skip_serializing_if = "Option::is_none")]
59    pub timeout_in_seconds: Option<i64>,
60}
61
62#[derive(Clone, Debug, Default, PartialEq, Serialize)]
63#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
64pub struct CancelDeploymentJobRequest {
65    /// <p>The deployment job ARN to cancel.</p>
66    #[serde(rename = "job")]
67    pub job: String,
68}
69
70#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
71#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
72pub struct CancelDeploymentJobResponse {}
73
74#[derive(Clone, Debug, Default, PartialEq, Serialize)]
75#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
76pub struct CancelSimulationJobBatchRequest {
77    /// <p>The id of the batch to cancel.</p>
78    #[serde(rename = "batch")]
79    pub batch: String,
80}
81
82#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
83#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
84pub struct CancelSimulationJobBatchResponse {}
85
86#[derive(Clone, Debug, Default, PartialEq, Serialize)]
87#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
88pub struct CancelSimulationJobRequest {
89    /// <p>The simulation job ARN to cancel.</p>
90    #[serde(rename = "job")]
91    pub job: String,
92}
93
94#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
95#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
96pub struct CancelSimulationJobResponse {}
97
98/// <p>Compute information for the simulation job.</p>
99#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
100pub struct Compute {
101    /// <p>The simulation unit limit. Your simulation is allocated CPU and memory proportional to the supplied simulation unit limit. A simulation unit is 1 vcpu and 2GB of memory. You are only billed for the SU utilization you consume up to the maximim value provided. </p>
102    #[serde(rename = "simulationUnitLimit")]
103    #[serde(skip_serializing_if = "Option::is_none")]
104    pub simulation_unit_limit: Option<i64>,
105}
106
107/// <p>Compute information for the simulation job</p>
108#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
109#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
110pub struct ComputeResponse {
111    /// <p>The simulation unit limit. Your simulation is allocated CPU and memory proportional to the supplied simulation unit limit. A simulation unit is 1 vcpu and 2GB of memory. You are only billed for the SU utilization you consume up to the maximim value provided. </p>
112    #[serde(rename = "simulationUnitLimit")]
113    #[serde(skip_serializing_if = "Option::is_none")]
114    pub simulation_unit_limit: Option<i64>,
115}
116
117#[derive(Clone, Debug, Default, PartialEq, Serialize)]
118#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
119pub struct CreateDeploymentJobRequest {
120    /// <p>Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.</p>
121    #[serde(rename = "clientRequestToken")]
122    pub client_request_token: String,
123    /// <p>The deployment application configuration.</p>
124    #[serde(rename = "deploymentApplicationConfigs")]
125    pub deployment_application_configs: Vec<DeploymentApplicationConfig>,
126    /// <p>The requested deployment configuration.</p>
127    #[serde(rename = "deploymentConfig")]
128    #[serde(skip_serializing_if = "Option::is_none")]
129    pub deployment_config: Option<DeploymentConfig>,
130    /// <p>The Amazon Resource Name (ARN) of the fleet to deploy.</p>
131    #[serde(rename = "fleet")]
132    pub fleet: String,
133    /// <p>A map that contains tag keys and tag values that are attached to the deployment job.</p>
134    #[serde(rename = "tags")]
135    #[serde(skip_serializing_if = "Option::is_none")]
136    pub tags: Option<::std::collections::HashMap<String, String>>,
137}
138
139#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
140#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
141pub struct CreateDeploymentJobResponse {
142    /// <p>The Amazon Resource Name (ARN) of the deployment job.</p>
143    #[serde(rename = "arn")]
144    #[serde(skip_serializing_if = "Option::is_none")]
145    pub arn: Option<String>,
146    /// <p>The time, in milliseconds since the epoch, when the fleet was created.</p>
147    #[serde(rename = "createdAt")]
148    #[serde(skip_serializing_if = "Option::is_none")]
149    pub created_at: Option<f64>,
150    /// <p>The deployment application configuration.</p>
151    #[serde(rename = "deploymentApplicationConfigs")]
152    #[serde(skip_serializing_if = "Option::is_none")]
153    pub deployment_application_configs: Option<Vec<DeploymentApplicationConfig>>,
154    /// <p>The deployment configuration.</p>
155    #[serde(rename = "deploymentConfig")]
156    #[serde(skip_serializing_if = "Option::is_none")]
157    pub deployment_config: Option<DeploymentConfig>,
158    /// <p><p>The failure code of the simulation job if it failed:</p> <dl> <dt>BadPermissionError</dt> <dd> <p>AWS Greengrass requires a service-level role permission to access other services. The role must include the <a href="https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/service-role/AWSGreengrassResourceAccessRolePolicy$jsonEditor"> <code>AWSGreengrassResourceAccessRolePolicy</code> managed policy</a>. </p> </dd> <dt>ExtractingBundleFailure</dt> <dd> <p>The robot application could not be extracted from the bundle.</p> </dd> <dt>FailureThresholdBreached</dt> <dd> <p>The percentage of robots that could not be updated exceeded the percentage set for the deployment.</p> </dd> <dt>GreengrassDeploymentFailed</dt> <dd> <p>The robot application could not be deployed to the robot.</p> </dd> <dt>GreengrassGroupVersionDoesNotExist</dt> <dd> <p>The AWS Greengrass group or version associated with a robot is missing.</p> </dd> <dt>InternalServerError</dt> <dd> <p>An internal error has occurred. Retry your request, but if the problem persists, contact us with details.</p> </dd> <dt>MissingRobotApplicationArchitecture</dt> <dd> <p>The robot application does not have a source that matches the architecture of the robot.</p> </dd> <dt>MissingRobotDeploymentResource</dt> <dd> <p>One or more of the resources specified for the robot application are missing. For example, does the robot application have the correct launch package and launch file?</p> </dd> <dt>PostLaunchFileFailure</dt> <dd> <p>The post-launch script failed.</p> </dd> <dt>PreLaunchFileFailure</dt> <dd> <p>The pre-launch script failed.</p> </dd> <dt>ResourceNotFound</dt> <dd> <p>One or more deployment resources are missing. For example, do robot application source bundles still exist? </p> </dd> <dt>RobotDeploymentNoResponse</dt> <dd> <p>There is no response from the robot. It might not be powered on or connected to the internet.</p> </dd> </dl></p>
159    #[serde(rename = "failureCode")]
160    #[serde(skip_serializing_if = "Option::is_none")]
161    pub failure_code: Option<String>,
162    /// <p>The failure reason of the deployment job if it failed.</p>
163    #[serde(rename = "failureReason")]
164    #[serde(skip_serializing_if = "Option::is_none")]
165    pub failure_reason: Option<String>,
166    /// <p>The target fleet for the deployment job.</p>
167    #[serde(rename = "fleet")]
168    #[serde(skip_serializing_if = "Option::is_none")]
169    pub fleet: Option<String>,
170    /// <p>The status of the deployment job.</p>
171    #[serde(rename = "status")]
172    #[serde(skip_serializing_if = "Option::is_none")]
173    pub status: Option<String>,
174    /// <p>The list of all tags added to the deployment job.</p>
175    #[serde(rename = "tags")]
176    #[serde(skip_serializing_if = "Option::is_none")]
177    pub tags: Option<::std::collections::HashMap<String, String>>,
178}
179
180#[derive(Clone, Debug, Default, PartialEq, Serialize)]
181#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
182pub struct CreateFleetRequest {
183    /// <p>The name of the fleet.</p>
184    #[serde(rename = "name")]
185    pub name: String,
186    /// <p>A map that contains tag keys and tag values that are attached to the fleet.</p>
187    #[serde(rename = "tags")]
188    #[serde(skip_serializing_if = "Option::is_none")]
189    pub tags: Option<::std::collections::HashMap<String, String>>,
190}
191
192#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
193#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
194pub struct CreateFleetResponse {
195    /// <p>The Amazon Resource Name (ARN) of the fleet.</p>
196    #[serde(rename = "arn")]
197    #[serde(skip_serializing_if = "Option::is_none")]
198    pub arn: Option<String>,
199    /// <p>The time, in milliseconds since the epoch, when the fleet was created.</p>
200    #[serde(rename = "createdAt")]
201    #[serde(skip_serializing_if = "Option::is_none")]
202    pub created_at: Option<f64>,
203    /// <p>The name of the fleet.</p>
204    #[serde(rename = "name")]
205    #[serde(skip_serializing_if = "Option::is_none")]
206    pub name: Option<String>,
207    /// <p>The list of all tags added to the fleet.</p>
208    #[serde(rename = "tags")]
209    #[serde(skip_serializing_if = "Option::is_none")]
210    pub tags: Option<::std::collections::HashMap<String, String>>,
211}
212
213#[derive(Clone, Debug, Default, PartialEq, Serialize)]
214#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
215pub struct CreateRobotApplicationRequest {
216    /// <p>The name of the robot application.</p>
217    #[serde(rename = "name")]
218    pub name: String,
219    /// <p>The robot software suite (ROS distribuition) used by the robot application.</p>
220    #[serde(rename = "robotSoftwareSuite")]
221    pub robot_software_suite: RobotSoftwareSuite,
222    /// <p>The sources of the robot application.</p>
223    #[serde(rename = "sources")]
224    pub sources: Vec<SourceConfig>,
225    /// <p>A map that contains tag keys and tag values that are attached to the robot application.</p>
226    #[serde(rename = "tags")]
227    #[serde(skip_serializing_if = "Option::is_none")]
228    pub tags: Option<::std::collections::HashMap<String, String>>,
229}
230
231#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
232#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
233pub struct CreateRobotApplicationResponse {
234    /// <p>The Amazon Resource Name (ARN) of the robot application.</p>
235    #[serde(rename = "arn")]
236    #[serde(skip_serializing_if = "Option::is_none")]
237    pub arn: Option<String>,
238    /// <p>The time, in milliseconds since the epoch, when the robot application was last updated.</p>
239    #[serde(rename = "lastUpdatedAt")]
240    #[serde(skip_serializing_if = "Option::is_none")]
241    pub last_updated_at: Option<f64>,
242    /// <p>The name of the robot application.</p>
243    #[serde(rename = "name")]
244    #[serde(skip_serializing_if = "Option::is_none")]
245    pub name: Option<String>,
246    /// <p>The revision id of the robot application.</p>
247    #[serde(rename = "revisionId")]
248    #[serde(skip_serializing_if = "Option::is_none")]
249    pub revision_id: Option<String>,
250    /// <p>The robot software suite (ROS distribution) used by the robot application.</p>
251    #[serde(rename = "robotSoftwareSuite")]
252    #[serde(skip_serializing_if = "Option::is_none")]
253    pub robot_software_suite: Option<RobotSoftwareSuite>,
254    /// <p>The sources of the robot application.</p>
255    #[serde(rename = "sources")]
256    #[serde(skip_serializing_if = "Option::is_none")]
257    pub sources: Option<Vec<Source>>,
258    /// <p>The list of all tags added to the robot application.</p>
259    #[serde(rename = "tags")]
260    #[serde(skip_serializing_if = "Option::is_none")]
261    pub tags: Option<::std::collections::HashMap<String, String>>,
262    /// <p>The version of the robot application.</p>
263    #[serde(rename = "version")]
264    #[serde(skip_serializing_if = "Option::is_none")]
265    pub version: Option<String>,
266}
267
268#[derive(Clone, Debug, Default, PartialEq, Serialize)]
269#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
270pub struct CreateRobotApplicationVersionRequest {
271    /// <p>The application information for the robot application.</p>
272    #[serde(rename = "application")]
273    pub application: String,
274    /// <p>The current revision id for the robot application. If you provide a value and it matches the latest revision ID, a new version will be created.</p>
275    #[serde(rename = "currentRevisionId")]
276    #[serde(skip_serializing_if = "Option::is_none")]
277    pub current_revision_id: Option<String>,
278}
279
280#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
281#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
282pub struct CreateRobotApplicationVersionResponse {
283    /// <p>The Amazon Resource Name (ARN) of the robot application.</p>
284    #[serde(rename = "arn")]
285    #[serde(skip_serializing_if = "Option::is_none")]
286    pub arn: Option<String>,
287    /// <p>The time, in milliseconds since the epoch, when the robot application was last updated.</p>
288    #[serde(rename = "lastUpdatedAt")]
289    #[serde(skip_serializing_if = "Option::is_none")]
290    pub last_updated_at: Option<f64>,
291    /// <p>The name of the robot application.</p>
292    #[serde(rename = "name")]
293    #[serde(skip_serializing_if = "Option::is_none")]
294    pub name: Option<String>,
295    /// <p>The revision id of the robot application.</p>
296    #[serde(rename = "revisionId")]
297    #[serde(skip_serializing_if = "Option::is_none")]
298    pub revision_id: Option<String>,
299    /// <p>The robot software suite (ROS distribution) used by the robot application.</p>
300    #[serde(rename = "robotSoftwareSuite")]
301    #[serde(skip_serializing_if = "Option::is_none")]
302    pub robot_software_suite: Option<RobotSoftwareSuite>,
303    /// <p>The sources of the robot application.</p>
304    #[serde(rename = "sources")]
305    #[serde(skip_serializing_if = "Option::is_none")]
306    pub sources: Option<Vec<Source>>,
307    /// <p>The version of the robot application.</p>
308    #[serde(rename = "version")]
309    #[serde(skip_serializing_if = "Option::is_none")]
310    pub version: Option<String>,
311}
312
313#[derive(Clone, Debug, Default, PartialEq, Serialize)]
314#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
315pub struct CreateRobotRequest {
316    /// <p>The target architecture of the robot.</p>
317    #[serde(rename = "architecture")]
318    pub architecture: String,
319    /// <p>The Greengrass group id.</p>
320    #[serde(rename = "greengrassGroupId")]
321    pub greengrass_group_id: String,
322    /// <p>The name for the robot.</p>
323    #[serde(rename = "name")]
324    pub name: String,
325    /// <p>A map that contains tag keys and tag values that are attached to the robot.</p>
326    #[serde(rename = "tags")]
327    #[serde(skip_serializing_if = "Option::is_none")]
328    pub tags: Option<::std::collections::HashMap<String, String>>,
329}
330
331#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
332#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
333pub struct CreateRobotResponse {
334    /// <p>The target architecture of the robot.</p>
335    #[serde(rename = "architecture")]
336    #[serde(skip_serializing_if = "Option::is_none")]
337    pub architecture: Option<String>,
338    /// <p>The Amazon Resource Name (ARN) of the robot.</p>
339    #[serde(rename = "arn")]
340    #[serde(skip_serializing_if = "Option::is_none")]
341    pub arn: Option<String>,
342    /// <p>The time, in milliseconds since the epoch, when the robot was created.</p>
343    #[serde(rename = "createdAt")]
344    #[serde(skip_serializing_if = "Option::is_none")]
345    pub created_at: Option<f64>,
346    /// <p>The Amazon Resource Name (ARN) of the Greengrass group associated with the robot.</p>
347    #[serde(rename = "greengrassGroupId")]
348    #[serde(skip_serializing_if = "Option::is_none")]
349    pub greengrass_group_id: Option<String>,
350    /// <p>The name of the robot.</p>
351    #[serde(rename = "name")]
352    #[serde(skip_serializing_if = "Option::is_none")]
353    pub name: Option<String>,
354    /// <p>The list of all tags added to the robot.</p>
355    #[serde(rename = "tags")]
356    #[serde(skip_serializing_if = "Option::is_none")]
357    pub tags: Option<::std::collections::HashMap<String, String>>,
358}
359
360#[derive(Clone, Debug, Default, PartialEq, Serialize)]
361#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
362pub struct CreateSimulationApplicationRequest {
363    /// <p>The name of the simulation application.</p>
364    #[serde(rename = "name")]
365    pub name: String,
366    /// <p>The rendering engine for the simulation application.</p>
367    #[serde(rename = "renderingEngine")]
368    #[serde(skip_serializing_if = "Option::is_none")]
369    pub rendering_engine: Option<RenderingEngine>,
370    /// <p>The robot software suite (ROS distribution) used by the simulation application.</p>
371    #[serde(rename = "robotSoftwareSuite")]
372    pub robot_software_suite: RobotSoftwareSuite,
373    /// <p>The simulation software suite used by the simulation application.</p>
374    #[serde(rename = "simulationSoftwareSuite")]
375    pub simulation_software_suite: SimulationSoftwareSuite,
376    /// <p>The sources of the simulation application.</p>
377    #[serde(rename = "sources")]
378    pub sources: Vec<SourceConfig>,
379    /// <p>A map that contains tag keys and tag values that are attached to the simulation application.</p>
380    #[serde(rename = "tags")]
381    #[serde(skip_serializing_if = "Option::is_none")]
382    pub tags: Option<::std::collections::HashMap<String, String>>,
383}
384
385#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
386#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
387pub struct CreateSimulationApplicationResponse {
388    /// <p>The Amazon Resource Name (ARN) of the simulation application.</p>
389    #[serde(rename = "arn")]
390    #[serde(skip_serializing_if = "Option::is_none")]
391    pub arn: Option<String>,
392    /// <p>The time, in milliseconds since the epoch, when the simulation application was last updated.</p>
393    #[serde(rename = "lastUpdatedAt")]
394    #[serde(skip_serializing_if = "Option::is_none")]
395    pub last_updated_at: Option<f64>,
396    /// <p>The name of the simulation application.</p>
397    #[serde(rename = "name")]
398    #[serde(skip_serializing_if = "Option::is_none")]
399    pub name: Option<String>,
400    /// <p>The rendering engine for the simulation application.</p>
401    #[serde(rename = "renderingEngine")]
402    #[serde(skip_serializing_if = "Option::is_none")]
403    pub rendering_engine: Option<RenderingEngine>,
404    /// <p>The revision id of the simulation application.</p>
405    #[serde(rename = "revisionId")]
406    #[serde(skip_serializing_if = "Option::is_none")]
407    pub revision_id: Option<String>,
408    /// <p>Information about the robot software suite (ROS distribution).</p>
409    #[serde(rename = "robotSoftwareSuite")]
410    #[serde(skip_serializing_if = "Option::is_none")]
411    pub robot_software_suite: Option<RobotSoftwareSuite>,
412    /// <p>The simulation software suite used by the simulation application.</p>
413    #[serde(rename = "simulationSoftwareSuite")]
414    #[serde(skip_serializing_if = "Option::is_none")]
415    pub simulation_software_suite: Option<SimulationSoftwareSuite>,
416    /// <p>The sources of the simulation application.</p>
417    #[serde(rename = "sources")]
418    #[serde(skip_serializing_if = "Option::is_none")]
419    pub sources: Option<Vec<Source>>,
420    /// <p>The list of all tags added to the simulation application.</p>
421    #[serde(rename = "tags")]
422    #[serde(skip_serializing_if = "Option::is_none")]
423    pub tags: Option<::std::collections::HashMap<String, String>>,
424    /// <p>The version of the simulation application.</p>
425    #[serde(rename = "version")]
426    #[serde(skip_serializing_if = "Option::is_none")]
427    pub version: Option<String>,
428}
429
430#[derive(Clone, Debug, Default, PartialEq, Serialize)]
431#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
432pub struct CreateSimulationApplicationVersionRequest {
433    /// <p>The application information for the simulation application.</p>
434    #[serde(rename = "application")]
435    pub application: String,
436    /// <p>The current revision id for the simulation application. If you provide a value and it matches the latest revision ID, a new version will be created.</p>
437    #[serde(rename = "currentRevisionId")]
438    #[serde(skip_serializing_if = "Option::is_none")]
439    pub current_revision_id: Option<String>,
440}
441
442#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
443#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
444pub struct CreateSimulationApplicationVersionResponse {
445    /// <p>The Amazon Resource Name (ARN) of the simulation application.</p>
446    #[serde(rename = "arn")]
447    #[serde(skip_serializing_if = "Option::is_none")]
448    pub arn: Option<String>,
449    /// <p>The time, in milliseconds since the epoch, when the simulation application was last updated.</p>
450    #[serde(rename = "lastUpdatedAt")]
451    #[serde(skip_serializing_if = "Option::is_none")]
452    pub last_updated_at: Option<f64>,
453    /// <p>The name of the simulation application.</p>
454    #[serde(rename = "name")]
455    #[serde(skip_serializing_if = "Option::is_none")]
456    pub name: Option<String>,
457    /// <p>The rendering engine for the simulation application.</p>
458    #[serde(rename = "renderingEngine")]
459    #[serde(skip_serializing_if = "Option::is_none")]
460    pub rendering_engine: Option<RenderingEngine>,
461    /// <p>The revision ID of the simulation application.</p>
462    #[serde(rename = "revisionId")]
463    #[serde(skip_serializing_if = "Option::is_none")]
464    pub revision_id: Option<String>,
465    /// <p>Information about the robot software suite (ROS distribution).</p>
466    #[serde(rename = "robotSoftwareSuite")]
467    #[serde(skip_serializing_if = "Option::is_none")]
468    pub robot_software_suite: Option<RobotSoftwareSuite>,
469    /// <p>The simulation software suite used by the simulation application.</p>
470    #[serde(rename = "simulationSoftwareSuite")]
471    #[serde(skip_serializing_if = "Option::is_none")]
472    pub simulation_software_suite: Option<SimulationSoftwareSuite>,
473    /// <p>The sources of the simulation application.</p>
474    #[serde(rename = "sources")]
475    #[serde(skip_serializing_if = "Option::is_none")]
476    pub sources: Option<Vec<Source>>,
477    /// <p>The version of the simulation application.</p>
478    #[serde(rename = "version")]
479    #[serde(skip_serializing_if = "Option::is_none")]
480    pub version: Option<String>,
481}
482
483#[derive(Clone, Debug, Default, PartialEq, Serialize)]
484#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
485pub struct CreateSimulationJobRequest {
486    /// <p>Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.</p>
487    #[serde(rename = "clientRequestToken")]
488    #[serde(skip_serializing_if = "Option::is_none")]
489    pub client_request_token: Option<String>,
490    /// <p>Compute information for the simulation job.</p>
491    #[serde(rename = "compute")]
492    #[serde(skip_serializing_if = "Option::is_none")]
493    pub compute: Option<Compute>,
494    /// <p><p>Specify data sources to mount read-only files from S3 into your simulation. These files are available under <code>/opt/robomaker/datasources/data<em>source</em>name</code>. </p> <note> <p>There is a limit of 100 files and a combined size of 25GB for all <code>DataSourceConfig</code> objects. </p> </note></p>
495    #[serde(rename = "dataSources")]
496    #[serde(skip_serializing_if = "Option::is_none")]
497    pub data_sources: Option<Vec<DataSourceConfig>>,
498    /// <p><p>The failure behavior the simulation job.</p> <dl> <dt>Continue</dt> <dd> <p>Restart the simulation job in the same host instance.</p> </dd> <dt>Fail</dt> <dd> <p>Stop the simulation job and terminate the instance.</p> </dd> </dl></p>
499    #[serde(rename = "failureBehavior")]
500    #[serde(skip_serializing_if = "Option::is_none")]
501    pub failure_behavior: Option<String>,
502    /// <p>The IAM role name that allows the simulation instance to call the AWS APIs that are specified in its associated policies on your behalf. This is how credentials are passed in to your simulation job. </p>
503    #[serde(rename = "iamRole")]
504    pub iam_role: String,
505    /// <p>The logging configuration.</p>
506    #[serde(rename = "loggingConfig")]
507    #[serde(skip_serializing_if = "Option::is_none")]
508    pub logging_config: Option<LoggingConfig>,
509    /// <p>The maximum simulation job duration in seconds (up to 14 days or 1,209,600 seconds. When <code>maxJobDurationInSeconds</code> is reached, the simulation job will status will transition to <code>Completed</code>.</p>
510    #[serde(rename = "maxJobDurationInSeconds")]
511    pub max_job_duration_in_seconds: i64,
512    /// <p>Location for output files generated by the simulation job.</p>
513    #[serde(rename = "outputLocation")]
514    #[serde(skip_serializing_if = "Option::is_none")]
515    pub output_location: Option<OutputLocation>,
516    /// <p>The robot application to use in the simulation job.</p>
517    #[serde(rename = "robotApplications")]
518    #[serde(skip_serializing_if = "Option::is_none")]
519    pub robot_applications: Option<Vec<RobotApplicationConfig>>,
520    /// <p>The simulation application to use in the simulation job.</p>
521    #[serde(rename = "simulationApplications")]
522    #[serde(skip_serializing_if = "Option::is_none")]
523    pub simulation_applications: Option<Vec<SimulationApplicationConfig>>,
524    /// <p>A map that contains tag keys and tag values that are attached to the simulation job.</p>
525    #[serde(rename = "tags")]
526    #[serde(skip_serializing_if = "Option::is_none")]
527    pub tags: Option<::std::collections::HashMap<String, String>>,
528    /// <p>If your simulation job accesses resources in a VPC, you provide this parameter identifying the list of security group IDs and subnet IDs. These must belong to the same VPC. You must provide at least one security group and one subnet ID. </p>
529    #[serde(rename = "vpcConfig")]
530    #[serde(skip_serializing_if = "Option::is_none")]
531    pub vpc_config: Option<VPCConfig>,
532}
533
534#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
535#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
536pub struct CreateSimulationJobResponse {
537    /// <p>The Amazon Resource Name (ARN) of the simulation job.</p>
538    #[serde(rename = "arn")]
539    #[serde(skip_serializing_if = "Option::is_none")]
540    pub arn: Option<String>,
541    /// <p>Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.</p>
542    #[serde(rename = "clientRequestToken")]
543    #[serde(skip_serializing_if = "Option::is_none")]
544    pub client_request_token: Option<String>,
545    /// <p>Compute information for the simulation job.</p>
546    #[serde(rename = "compute")]
547    #[serde(skip_serializing_if = "Option::is_none")]
548    pub compute: Option<ComputeResponse>,
549    /// <p>The data sources for the simulation job.</p>
550    #[serde(rename = "dataSources")]
551    #[serde(skip_serializing_if = "Option::is_none")]
552    pub data_sources: Option<Vec<DataSource>>,
553    /// <p>the failure behavior for the simulation job.</p>
554    #[serde(rename = "failureBehavior")]
555    #[serde(skip_serializing_if = "Option::is_none")]
556    pub failure_behavior: Option<String>,
557    /// <p><p>The failure code of the simulation job if it failed:</p> <dl> <dt>InternalServiceError</dt> <dd> <p>Internal service error.</p> </dd> <dt>RobotApplicationCrash</dt> <dd> <p>Robot application exited abnormally.</p> </dd> <dt>SimulationApplicationCrash</dt> <dd> <p> Simulation application exited abnormally.</p> </dd> <dt>BadPermissionsRobotApplication</dt> <dd> <p>Robot application bundle could not be downloaded.</p> </dd> <dt>BadPermissionsSimulationApplication</dt> <dd> <p>Simulation application bundle could not be downloaded.</p> </dd> <dt>BadPermissionsS3Output</dt> <dd> <p>Unable to publish outputs to customer-provided S3 bucket.</p> </dd> <dt>BadPermissionsCloudwatchLogs</dt> <dd> <p>Unable to publish logs to customer-provided CloudWatch Logs resource.</p> </dd> <dt>SubnetIpLimitExceeded</dt> <dd> <p>Subnet IP limit exceeded.</p> </dd> <dt>ENILimitExceeded</dt> <dd> <p>ENI limit exceeded.</p> </dd> <dt>BadPermissionsUserCredentials</dt> <dd> <p>Unable to use the Role provided.</p> </dd> <dt>InvalidBundleRobotApplication</dt> <dd> <p>Robot bundle cannot be extracted (invalid format, bundling error, or other issue).</p> </dd> <dt>InvalidBundleSimulationApplication</dt> <dd> <p>Simulation bundle cannot be extracted (invalid format, bundling error, or other issue).</p> </dd> <dt>RobotApplicationVersionMismatchedEtag</dt> <dd> <p>Etag for RobotApplication does not match value during version creation.</p> </dd> <dt>SimulationApplicationVersionMismatchedEtag</dt> <dd> <p>Etag for SimulationApplication does not match value during version creation.</p> </dd> </dl></p>
558    #[serde(rename = "failureCode")]
559    #[serde(skip_serializing_if = "Option::is_none")]
560    pub failure_code: Option<String>,
561    /// <p>The IAM role that allows the simulation job to call the AWS APIs that are specified in its associated policies on your behalf.</p>
562    #[serde(rename = "iamRole")]
563    #[serde(skip_serializing_if = "Option::is_none")]
564    pub iam_role: Option<String>,
565    /// <p>The time, in milliseconds since the epoch, when the simulation job was last started.</p>
566    #[serde(rename = "lastStartedAt")]
567    #[serde(skip_serializing_if = "Option::is_none")]
568    pub last_started_at: Option<f64>,
569    /// <p>The time, in milliseconds since the epoch, when the simulation job was last updated.</p>
570    #[serde(rename = "lastUpdatedAt")]
571    #[serde(skip_serializing_if = "Option::is_none")]
572    pub last_updated_at: Option<f64>,
573    /// <p>The logging configuration.</p>
574    #[serde(rename = "loggingConfig")]
575    #[serde(skip_serializing_if = "Option::is_none")]
576    pub logging_config: Option<LoggingConfig>,
577    /// <p>The maximum simulation job duration in seconds. </p>
578    #[serde(rename = "maxJobDurationInSeconds")]
579    #[serde(skip_serializing_if = "Option::is_none")]
580    pub max_job_duration_in_seconds: Option<i64>,
581    /// <p>Simulation job output files location.</p>
582    #[serde(rename = "outputLocation")]
583    #[serde(skip_serializing_if = "Option::is_none")]
584    pub output_location: Option<OutputLocation>,
585    /// <p>The robot application used by the simulation job.</p>
586    #[serde(rename = "robotApplications")]
587    #[serde(skip_serializing_if = "Option::is_none")]
588    pub robot_applications: Option<Vec<RobotApplicationConfig>>,
589    /// <p>The simulation application used by the simulation job.</p>
590    #[serde(rename = "simulationApplications")]
591    #[serde(skip_serializing_if = "Option::is_none")]
592    pub simulation_applications: Option<Vec<SimulationApplicationConfig>>,
593    /// <p>The simulation job execution duration in milliseconds.</p>
594    #[serde(rename = "simulationTimeMillis")]
595    #[serde(skip_serializing_if = "Option::is_none")]
596    pub simulation_time_millis: Option<i64>,
597    /// <p>The status of the simulation job.</p>
598    #[serde(rename = "status")]
599    #[serde(skip_serializing_if = "Option::is_none")]
600    pub status: Option<String>,
601    /// <p>The list of all tags added to the simulation job.</p>
602    #[serde(rename = "tags")]
603    #[serde(skip_serializing_if = "Option::is_none")]
604    pub tags: Option<::std::collections::HashMap<String, String>>,
605    /// <p>Information about the vpc configuration.</p>
606    #[serde(rename = "vpcConfig")]
607    #[serde(skip_serializing_if = "Option::is_none")]
608    pub vpc_config: Option<VPCConfigResponse>,
609}
610
611/// <p>Information about a data source.</p>
612#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
613#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
614pub struct DataSource {
615    /// <p>The name of the data source.</p>
616    #[serde(rename = "name")]
617    #[serde(skip_serializing_if = "Option::is_none")]
618    pub name: Option<String>,
619    /// <p>The S3 bucket where the data files are located.</p>
620    #[serde(rename = "s3Bucket")]
621    #[serde(skip_serializing_if = "Option::is_none")]
622    pub s_3_bucket: Option<String>,
623    /// <p>The list of S3 keys identifying the data source files.</p>
624    #[serde(rename = "s3Keys")]
625    #[serde(skip_serializing_if = "Option::is_none")]
626    pub s_3_keys: Option<Vec<S3KeyOutput>>,
627}
628
629/// <p>Information about a data source.</p>
630#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
631pub struct DataSourceConfig {
632    /// <p>The name of the data source.</p>
633    #[serde(rename = "name")]
634    pub name: String,
635    /// <p>The S3 bucket where the data files are located.</p>
636    #[serde(rename = "s3Bucket")]
637    pub s_3_bucket: String,
638    /// <p>The list of S3 keys identifying the data source files.</p>
639    #[serde(rename = "s3Keys")]
640    pub s_3_keys: Vec<String>,
641}
642
643#[derive(Clone, Debug, Default, PartialEq, Serialize)]
644#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
645pub struct DeleteFleetRequest {
646    /// <p>The Amazon Resource Name (ARN) of the fleet.</p>
647    #[serde(rename = "fleet")]
648    pub fleet: String,
649}
650
651#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
652#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
653pub struct DeleteFleetResponse {}
654
655#[derive(Clone, Debug, Default, PartialEq, Serialize)]
656#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
657pub struct DeleteRobotApplicationRequest {
658    /// <p>The Amazon Resource Name (ARN) of the the robot application.</p>
659    #[serde(rename = "application")]
660    pub application: String,
661    /// <p>The version of the robot application to delete.</p>
662    #[serde(rename = "applicationVersion")]
663    #[serde(skip_serializing_if = "Option::is_none")]
664    pub application_version: Option<String>,
665}
666
667#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
668#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
669pub struct DeleteRobotApplicationResponse {}
670
671#[derive(Clone, Debug, Default, PartialEq, Serialize)]
672#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
673pub struct DeleteRobotRequest {
674    /// <p>The Amazon Resource Name (ARN) of the robot.</p>
675    #[serde(rename = "robot")]
676    pub robot: String,
677}
678
679#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
680#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
681pub struct DeleteRobotResponse {}
682
683#[derive(Clone, Debug, Default, PartialEq, Serialize)]
684#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
685pub struct DeleteSimulationApplicationRequest {
686    /// <p>The application information for the simulation application to delete.</p>
687    #[serde(rename = "application")]
688    pub application: String,
689    /// <p>The version of the simulation application to delete.</p>
690    #[serde(rename = "applicationVersion")]
691    #[serde(skip_serializing_if = "Option::is_none")]
692    pub application_version: Option<String>,
693}
694
695#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
696#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
697pub struct DeleteSimulationApplicationResponse {}
698
699/// <p>Information about a deployment application configuration.</p>
700#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
701pub struct DeploymentApplicationConfig {
702    /// <p>The Amazon Resource Name (ARN) of the robot application.</p>
703    #[serde(rename = "application")]
704    pub application: String,
705    /// <p>The version of the application.</p>
706    #[serde(rename = "applicationVersion")]
707    pub application_version: String,
708    /// <p>The launch configuration.</p>
709    #[serde(rename = "launchConfig")]
710    pub launch_config: DeploymentLaunchConfig,
711}
712
713/// <p>Information about a deployment configuration.</p>
714#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
715pub struct DeploymentConfig {
716    /// <p>The percentage of robots receiving the deployment at the same time.</p>
717    #[serde(rename = "concurrentDeploymentPercentage")]
718    #[serde(skip_serializing_if = "Option::is_none")]
719    pub concurrent_deployment_percentage: Option<i64>,
720    /// <p>The download condition file.</p>
721    #[serde(rename = "downloadConditionFile")]
722    #[serde(skip_serializing_if = "Option::is_none")]
723    pub download_condition_file: Option<S3Object>,
724    /// <p>The percentage of deployments that need to fail before stopping deployment.</p>
725    #[serde(rename = "failureThresholdPercentage")]
726    #[serde(skip_serializing_if = "Option::is_none")]
727    pub failure_threshold_percentage: Option<i64>,
728    /// <p>The amount of time, in seconds, to wait for deployment to a single robot to complete. Choose a time between 1 minute and 7 days. The default is 5 hours.</p>
729    #[serde(rename = "robotDeploymentTimeoutInSeconds")]
730    #[serde(skip_serializing_if = "Option::is_none")]
731    pub robot_deployment_timeout_in_seconds: Option<i64>,
732}
733
734/// <p>Information about a deployment job.</p>
735#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
736#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
737pub struct DeploymentJob {
738    /// <p>The Amazon Resource Name (ARN) of the deployment job.</p>
739    #[serde(rename = "arn")]
740    #[serde(skip_serializing_if = "Option::is_none")]
741    pub arn: Option<String>,
742    /// <p>The time, in milliseconds since the epoch, when the deployment job was created.</p>
743    #[serde(rename = "createdAt")]
744    #[serde(skip_serializing_if = "Option::is_none")]
745    pub created_at: Option<f64>,
746    /// <p>The deployment application configuration.</p>
747    #[serde(rename = "deploymentApplicationConfigs")]
748    #[serde(skip_serializing_if = "Option::is_none")]
749    pub deployment_application_configs: Option<Vec<DeploymentApplicationConfig>>,
750    /// <p>The deployment configuration.</p>
751    #[serde(rename = "deploymentConfig")]
752    #[serde(skip_serializing_if = "Option::is_none")]
753    pub deployment_config: Option<DeploymentConfig>,
754    /// <p>The deployment job failure code.</p>
755    #[serde(rename = "failureCode")]
756    #[serde(skip_serializing_if = "Option::is_none")]
757    pub failure_code: Option<String>,
758    /// <p>A short description of the reason why the deployment job failed.</p>
759    #[serde(rename = "failureReason")]
760    #[serde(skip_serializing_if = "Option::is_none")]
761    pub failure_reason: Option<String>,
762    /// <p>The Amazon Resource Name (ARN) of the fleet.</p>
763    #[serde(rename = "fleet")]
764    #[serde(skip_serializing_if = "Option::is_none")]
765    pub fleet: Option<String>,
766    /// <p>The status of the deployment job.</p>
767    #[serde(rename = "status")]
768    #[serde(skip_serializing_if = "Option::is_none")]
769    pub status: Option<String>,
770}
771
772/// <p>Configuration information for a deployment launch.</p>
773#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
774pub struct DeploymentLaunchConfig {
775    /// <p>An array of key/value pairs specifying environment variables for the robot application</p>
776    #[serde(rename = "environmentVariables")]
777    #[serde(skip_serializing_if = "Option::is_none")]
778    pub environment_variables: Option<::std::collections::HashMap<String, String>>,
779    /// <p>The launch file name.</p>
780    #[serde(rename = "launchFile")]
781    pub launch_file: String,
782    /// <p>The package name.</p>
783    #[serde(rename = "packageName")]
784    pub package_name: String,
785    /// <p>The deployment post-launch file. This file will be executed after the launch file.</p>
786    #[serde(rename = "postLaunchFile")]
787    #[serde(skip_serializing_if = "Option::is_none")]
788    pub post_launch_file: Option<String>,
789    /// <p>The deployment pre-launch file. This file will be executed prior to the launch file.</p>
790    #[serde(rename = "preLaunchFile")]
791    #[serde(skip_serializing_if = "Option::is_none")]
792    pub pre_launch_file: Option<String>,
793}
794
795#[derive(Clone, Debug, Default, PartialEq, Serialize)]
796#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
797pub struct DeregisterRobotRequest {
798    /// <p>The Amazon Resource Name (ARN) of the fleet.</p>
799    #[serde(rename = "fleet")]
800    pub fleet: String,
801    /// <p>The Amazon Resource Name (ARN) of the robot.</p>
802    #[serde(rename = "robot")]
803    pub robot: String,
804}
805
806#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
807#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
808pub struct DeregisterRobotResponse {
809    /// <p>The Amazon Resource Name (ARN) of the fleet.</p>
810    #[serde(rename = "fleet")]
811    #[serde(skip_serializing_if = "Option::is_none")]
812    pub fleet: Option<String>,
813    /// <p>The Amazon Resource Name (ARN) of the robot.</p>
814    #[serde(rename = "robot")]
815    #[serde(skip_serializing_if = "Option::is_none")]
816    pub robot: Option<String>,
817}
818
819#[derive(Clone, Debug, Default, PartialEq, Serialize)]
820#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
821pub struct DescribeDeploymentJobRequest {
822    /// <p>The Amazon Resource Name (ARN) of the deployment job.</p>
823    #[serde(rename = "job")]
824    pub job: String,
825}
826
827#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
828#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
829pub struct DescribeDeploymentJobResponse {
830    /// <p>The Amazon Resource Name (ARN) of the deployment job.</p>
831    #[serde(rename = "arn")]
832    #[serde(skip_serializing_if = "Option::is_none")]
833    pub arn: Option<String>,
834    /// <p>The time, in milliseconds since the epoch, when the deployment job was created.</p>
835    #[serde(rename = "createdAt")]
836    #[serde(skip_serializing_if = "Option::is_none")]
837    pub created_at: Option<f64>,
838    /// <p>The deployment application configuration.</p>
839    #[serde(rename = "deploymentApplicationConfigs")]
840    #[serde(skip_serializing_if = "Option::is_none")]
841    pub deployment_application_configs: Option<Vec<DeploymentApplicationConfig>>,
842    /// <p>The deployment configuration.</p>
843    #[serde(rename = "deploymentConfig")]
844    #[serde(skip_serializing_if = "Option::is_none")]
845    pub deployment_config: Option<DeploymentConfig>,
846    /// <p>The deployment job failure code.</p>
847    #[serde(rename = "failureCode")]
848    #[serde(skip_serializing_if = "Option::is_none")]
849    pub failure_code: Option<String>,
850    /// <p>A short description of the reason why the deployment job failed.</p>
851    #[serde(rename = "failureReason")]
852    #[serde(skip_serializing_if = "Option::is_none")]
853    pub failure_reason: Option<String>,
854    /// <p>The Amazon Resource Name (ARN) of the fleet.</p>
855    #[serde(rename = "fleet")]
856    #[serde(skip_serializing_if = "Option::is_none")]
857    pub fleet: Option<String>,
858    /// <p>A list of robot deployment summaries.</p>
859    #[serde(rename = "robotDeploymentSummary")]
860    #[serde(skip_serializing_if = "Option::is_none")]
861    pub robot_deployment_summary: Option<Vec<RobotDeployment>>,
862    /// <p>The status of the deployment job.</p>
863    #[serde(rename = "status")]
864    #[serde(skip_serializing_if = "Option::is_none")]
865    pub status: Option<String>,
866    /// <p>The list of all tags added to the specified deployment job.</p>
867    #[serde(rename = "tags")]
868    #[serde(skip_serializing_if = "Option::is_none")]
869    pub tags: Option<::std::collections::HashMap<String, String>>,
870}
871
872#[derive(Clone, Debug, Default, PartialEq, Serialize)]
873#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
874pub struct DescribeFleetRequest {
875    /// <p>The Amazon Resource Name (ARN) of the fleet.</p>
876    #[serde(rename = "fleet")]
877    pub fleet: String,
878}
879
880#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
881#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
882pub struct DescribeFleetResponse {
883    /// <p>The Amazon Resource Name (ARN) of the fleet.</p>
884    #[serde(rename = "arn")]
885    #[serde(skip_serializing_if = "Option::is_none")]
886    pub arn: Option<String>,
887    /// <p>The time, in milliseconds since the epoch, when the fleet was created.</p>
888    #[serde(rename = "createdAt")]
889    #[serde(skip_serializing_if = "Option::is_none")]
890    pub created_at: Option<f64>,
891    /// <p>The Amazon Resource Name (ARN) of the last deployment job.</p>
892    #[serde(rename = "lastDeploymentJob")]
893    #[serde(skip_serializing_if = "Option::is_none")]
894    pub last_deployment_job: Option<String>,
895    /// <p>The status of the last deployment.</p>
896    #[serde(rename = "lastDeploymentStatus")]
897    #[serde(skip_serializing_if = "Option::is_none")]
898    pub last_deployment_status: Option<String>,
899    /// <p>The time of the last deployment.</p>
900    #[serde(rename = "lastDeploymentTime")]
901    #[serde(skip_serializing_if = "Option::is_none")]
902    pub last_deployment_time: Option<f64>,
903    /// <p>The name of the fleet.</p>
904    #[serde(rename = "name")]
905    #[serde(skip_serializing_if = "Option::is_none")]
906    pub name: Option<String>,
907    /// <p>A list of robots.</p>
908    #[serde(rename = "robots")]
909    #[serde(skip_serializing_if = "Option::is_none")]
910    pub robots: Option<Vec<Robot>>,
911    /// <p>The list of all tags added to the specified fleet.</p>
912    #[serde(rename = "tags")]
913    #[serde(skip_serializing_if = "Option::is_none")]
914    pub tags: Option<::std::collections::HashMap<String, String>>,
915}
916
917#[derive(Clone, Debug, Default, PartialEq, Serialize)]
918#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
919pub struct DescribeRobotApplicationRequest {
920    /// <p>The Amazon Resource Name (ARN) of the robot application.</p>
921    #[serde(rename = "application")]
922    pub application: String,
923    /// <p>The version of the robot application to describe.</p>
924    #[serde(rename = "applicationVersion")]
925    #[serde(skip_serializing_if = "Option::is_none")]
926    pub application_version: Option<String>,
927}
928
929#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
930#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
931pub struct DescribeRobotApplicationResponse {
932    /// <p>The Amazon Resource Name (ARN) of the robot application.</p>
933    #[serde(rename = "arn")]
934    #[serde(skip_serializing_if = "Option::is_none")]
935    pub arn: Option<String>,
936    /// <p>The time, in milliseconds since the epoch, when the robot application was last updated.</p>
937    #[serde(rename = "lastUpdatedAt")]
938    #[serde(skip_serializing_if = "Option::is_none")]
939    pub last_updated_at: Option<f64>,
940    /// <p>The name of the robot application.</p>
941    #[serde(rename = "name")]
942    #[serde(skip_serializing_if = "Option::is_none")]
943    pub name: Option<String>,
944    /// <p>The revision id of the robot application.</p>
945    #[serde(rename = "revisionId")]
946    #[serde(skip_serializing_if = "Option::is_none")]
947    pub revision_id: Option<String>,
948    /// <p>The robot software suite (ROS distribution) used by the robot application.</p>
949    #[serde(rename = "robotSoftwareSuite")]
950    #[serde(skip_serializing_if = "Option::is_none")]
951    pub robot_software_suite: Option<RobotSoftwareSuite>,
952    /// <p>The sources of the robot application.</p>
953    #[serde(rename = "sources")]
954    #[serde(skip_serializing_if = "Option::is_none")]
955    pub sources: Option<Vec<Source>>,
956    /// <p>The list of all tags added to the specified robot application.</p>
957    #[serde(rename = "tags")]
958    #[serde(skip_serializing_if = "Option::is_none")]
959    pub tags: Option<::std::collections::HashMap<String, String>>,
960    /// <p>The version of the robot application.</p>
961    #[serde(rename = "version")]
962    #[serde(skip_serializing_if = "Option::is_none")]
963    pub version: Option<String>,
964}
965
966#[derive(Clone, Debug, Default, PartialEq, Serialize)]
967#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
968pub struct DescribeRobotRequest {
969    /// <p>The Amazon Resource Name (ARN) of the robot to be described.</p>
970    #[serde(rename = "robot")]
971    pub robot: String,
972}
973
974#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
975#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
976pub struct DescribeRobotResponse {
977    /// <p>The target architecture of the robot application.</p>
978    #[serde(rename = "architecture")]
979    #[serde(skip_serializing_if = "Option::is_none")]
980    pub architecture: Option<String>,
981    /// <p>The Amazon Resource Name (ARN) of the robot.</p>
982    #[serde(rename = "arn")]
983    #[serde(skip_serializing_if = "Option::is_none")]
984    pub arn: Option<String>,
985    /// <p>The time, in milliseconds since the epoch, when the robot was created.</p>
986    #[serde(rename = "createdAt")]
987    #[serde(skip_serializing_if = "Option::is_none")]
988    pub created_at: Option<f64>,
989    /// <p>The Amazon Resource Name (ARN) of the fleet.</p>
990    #[serde(rename = "fleetArn")]
991    #[serde(skip_serializing_if = "Option::is_none")]
992    pub fleet_arn: Option<String>,
993    /// <p>The Greengrass group id.</p>
994    #[serde(rename = "greengrassGroupId")]
995    #[serde(skip_serializing_if = "Option::is_none")]
996    pub greengrass_group_id: Option<String>,
997    /// <p>The Amazon Resource Name (ARN) of the last deployment job.</p>
998    #[serde(rename = "lastDeploymentJob")]
999    #[serde(skip_serializing_if = "Option::is_none")]
1000    pub last_deployment_job: Option<String>,
1001    /// <p>The time of the last deployment job.</p>
1002    #[serde(rename = "lastDeploymentTime")]
1003    #[serde(skip_serializing_if = "Option::is_none")]
1004    pub last_deployment_time: Option<f64>,
1005    /// <p>The name of the robot.</p>
1006    #[serde(rename = "name")]
1007    #[serde(skip_serializing_if = "Option::is_none")]
1008    pub name: Option<String>,
1009    /// <p>The status of the fleet.</p>
1010    #[serde(rename = "status")]
1011    #[serde(skip_serializing_if = "Option::is_none")]
1012    pub status: Option<String>,
1013    /// <p>The list of all tags added to the specified robot.</p>
1014    #[serde(rename = "tags")]
1015    #[serde(skip_serializing_if = "Option::is_none")]
1016    pub tags: Option<::std::collections::HashMap<String, String>>,
1017}
1018
1019#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1020#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1021pub struct DescribeSimulationApplicationRequest {
1022    /// <p>The application information for the simulation application.</p>
1023    #[serde(rename = "application")]
1024    pub application: String,
1025    /// <p>The version of the simulation application to describe.</p>
1026    #[serde(rename = "applicationVersion")]
1027    #[serde(skip_serializing_if = "Option::is_none")]
1028    pub application_version: Option<String>,
1029}
1030
1031#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1032#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1033pub struct DescribeSimulationApplicationResponse {
1034    /// <p>The Amazon Resource Name (ARN) of the robot simulation application.</p>
1035    #[serde(rename = "arn")]
1036    #[serde(skip_serializing_if = "Option::is_none")]
1037    pub arn: Option<String>,
1038    /// <p>The time, in milliseconds since the epoch, when the simulation application was last updated.</p>
1039    #[serde(rename = "lastUpdatedAt")]
1040    #[serde(skip_serializing_if = "Option::is_none")]
1041    pub last_updated_at: Option<f64>,
1042    /// <p>The name of the simulation application.</p>
1043    #[serde(rename = "name")]
1044    #[serde(skip_serializing_if = "Option::is_none")]
1045    pub name: Option<String>,
1046    /// <p>The rendering engine for the simulation application.</p>
1047    #[serde(rename = "renderingEngine")]
1048    #[serde(skip_serializing_if = "Option::is_none")]
1049    pub rendering_engine: Option<RenderingEngine>,
1050    /// <p>The revision id of the simulation application.</p>
1051    #[serde(rename = "revisionId")]
1052    #[serde(skip_serializing_if = "Option::is_none")]
1053    pub revision_id: Option<String>,
1054    /// <p>Information about the robot software suite (ROS distribution).</p>
1055    #[serde(rename = "robotSoftwareSuite")]
1056    #[serde(skip_serializing_if = "Option::is_none")]
1057    pub robot_software_suite: Option<RobotSoftwareSuite>,
1058    /// <p>The simulation software suite used by the simulation application.</p>
1059    #[serde(rename = "simulationSoftwareSuite")]
1060    #[serde(skip_serializing_if = "Option::is_none")]
1061    pub simulation_software_suite: Option<SimulationSoftwareSuite>,
1062    /// <p>The sources of the simulation application.</p>
1063    #[serde(rename = "sources")]
1064    #[serde(skip_serializing_if = "Option::is_none")]
1065    pub sources: Option<Vec<Source>>,
1066    /// <p>The list of all tags added to the specified simulation application.</p>
1067    #[serde(rename = "tags")]
1068    #[serde(skip_serializing_if = "Option::is_none")]
1069    pub tags: Option<::std::collections::HashMap<String, String>>,
1070    /// <p>The version of the simulation application.</p>
1071    #[serde(rename = "version")]
1072    #[serde(skip_serializing_if = "Option::is_none")]
1073    pub version: Option<String>,
1074}
1075
1076#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1077#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1078pub struct DescribeSimulationJobBatchRequest {
1079    /// <p>The id of the batch to describe.</p>
1080    #[serde(rename = "batch")]
1081    pub batch: String,
1082}
1083
1084#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1085#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1086pub struct DescribeSimulationJobBatchResponse {
1087    /// <p>The Amazon Resource Name (ARN) of the batch.</p>
1088    #[serde(rename = "arn")]
1089    #[serde(skip_serializing_if = "Option::is_none")]
1090    pub arn: Option<String>,
1091    /// <p>The batch policy.</p>
1092    #[serde(rename = "batchPolicy")]
1093    #[serde(skip_serializing_if = "Option::is_none")]
1094    pub batch_policy: Option<BatchPolicy>,
1095    /// <p>Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.</p>
1096    #[serde(rename = "clientRequestToken")]
1097    #[serde(skip_serializing_if = "Option::is_none")]
1098    pub client_request_token: Option<String>,
1099    /// <p>The time, in milliseconds since the epoch, when the simulation job batch was created.</p>
1100    #[serde(rename = "createdAt")]
1101    #[serde(skip_serializing_if = "Option::is_none")]
1102    pub created_at: Option<f64>,
1103    /// <p>A list of created simulation job summaries.</p>
1104    #[serde(rename = "createdRequests")]
1105    #[serde(skip_serializing_if = "Option::is_none")]
1106    pub created_requests: Option<Vec<SimulationJobSummary>>,
1107    /// <p>A list of failed create simulation job requests. The request failed to be created into a simulation job. Failed requests do not have a simulation job ID. </p>
1108    #[serde(rename = "failedRequests")]
1109    #[serde(skip_serializing_if = "Option::is_none")]
1110    pub failed_requests: Option<Vec<FailedCreateSimulationJobRequest>>,
1111    /// <p>The failure code of the simulation job batch.</p>
1112    #[serde(rename = "failureCode")]
1113    #[serde(skip_serializing_if = "Option::is_none")]
1114    pub failure_code: Option<String>,
1115    /// <p>The reason the simulation job batch failed.</p>
1116    #[serde(rename = "failureReason")]
1117    #[serde(skip_serializing_if = "Option::is_none")]
1118    pub failure_reason: Option<String>,
1119    /// <p>The time, in milliseconds since the epoch, when the simulation job batch was last updated.</p>
1120    #[serde(rename = "lastUpdatedAt")]
1121    #[serde(skip_serializing_if = "Option::is_none")]
1122    pub last_updated_at: Option<f64>,
1123    /// <p>A list of pending simulation job requests. These requests have not yet been created into simulation jobs.</p>
1124    #[serde(rename = "pendingRequests")]
1125    #[serde(skip_serializing_if = "Option::is_none")]
1126    pub pending_requests: Option<Vec<SimulationJobRequest>>,
1127    /// <p><p>The status of the batch.</p> <dl> <dt>Pending</dt> <dd> <p>The simulation job batch request is pending.</p> </dd> <dt>InProgress</dt> <dd> <p>The simulation job batch is in progress. </p> </dd> <dt>Failed</dt> <dd> <p>The simulation job batch failed. One or more simulation job requests could not be completed due to an internal failure (like <code>InternalServiceError</code>). See <code>failureCode</code> and <code>failureReason</code> for more information.</p> </dd> <dt>Completed</dt> <dd> <p>The simulation batch job completed. A batch is complete when (1) there are no pending simulation job requests in the batch and none of the failed simulation job requests are due to <code>InternalServiceError</code> and (2) when all created simulation jobs have reached a terminal state (for example, <code>Completed</code> or <code>Failed</code>). </p> </dd> <dt>Canceled</dt> <dd> <p>The simulation batch job was cancelled.</p> </dd> <dt>Canceling</dt> <dd> <p>The simulation batch job is being cancelled.</p> </dd> <dt>Completing</dt> <dd> <p>The simulation batch job is completing.</p> </dd> <dt>TimingOut</dt> <dd> <p>The simulation job batch is timing out.</p> <p>If a batch timing out, and there are pending requests that were failing due to an internal failure (like <code>InternalServiceError</code>), the batch status will be <code>Failed</code>. If there are no such failing request, the batch status will be <code>TimedOut</code>. </p> </dd> <dt>TimedOut</dt> <dd> <p>The simulation batch job timed out.</p> </dd> </dl></p>
1128    #[serde(rename = "status")]
1129    #[serde(skip_serializing_if = "Option::is_none")]
1130    pub status: Option<String>,
1131    /// <p>A map that contains tag keys and tag values that are attached to the simulation job batch.</p>
1132    #[serde(rename = "tags")]
1133    #[serde(skip_serializing_if = "Option::is_none")]
1134    pub tags: Option<::std::collections::HashMap<String, String>>,
1135}
1136
1137#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1138#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1139pub struct DescribeSimulationJobRequest {
1140    /// <p>The Amazon Resource Name (ARN) of the simulation job to be described.</p>
1141    #[serde(rename = "job")]
1142    pub job: String,
1143}
1144
1145#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1146#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1147pub struct DescribeSimulationJobResponse {
1148    /// <p>The Amazon Resource Name (ARN) of the simulation job.</p>
1149    #[serde(rename = "arn")]
1150    #[serde(skip_serializing_if = "Option::is_none")]
1151    pub arn: Option<String>,
1152    /// <p>Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.</p>
1153    #[serde(rename = "clientRequestToken")]
1154    #[serde(skip_serializing_if = "Option::is_none")]
1155    pub client_request_token: Option<String>,
1156    /// <p>Compute information for the simulation job.</p>
1157    #[serde(rename = "compute")]
1158    #[serde(skip_serializing_if = "Option::is_none")]
1159    pub compute: Option<ComputeResponse>,
1160    /// <p>The data sources for the simulation job.</p>
1161    #[serde(rename = "dataSources")]
1162    #[serde(skip_serializing_if = "Option::is_none")]
1163    pub data_sources: Option<Vec<DataSource>>,
1164    /// <p>The failure behavior for the simulation job.</p>
1165    #[serde(rename = "failureBehavior")]
1166    #[serde(skip_serializing_if = "Option::is_none")]
1167    pub failure_behavior: Option<String>,
1168    /// <p><p>The failure code of the simulation job if it failed:</p> <dl> <dt>InternalServiceError</dt> <dd> <p>Internal service error.</p> </dd> <dt>RobotApplicationCrash</dt> <dd> <p>Robot application exited abnormally.</p> </dd> <dt>SimulationApplicationCrash</dt> <dd> <p> Simulation application exited abnormally.</p> </dd> <dt>BadPermissionsRobotApplication</dt> <dd> <p>Robot application bundle could not be downloaded.</p> </dd> <dt>BadPermissionsSimulationApplication</dt> <dd> <p>Simulation application bundle could not be downloaded.</p> </dd> <dt>BadPermissionsS3Output</dt> <dd> <p>Unable to publish outputs to customer-provided S3 bucket.</p> </dd> <dt>BadPermissionsCloudwatchLogs</dt> <dd> <p>Unable to publish logs to customer-provided CloudWatch Logs resource.</p> </dd> <dt>SubnetIpLimitExceeded</dt> <dd> <p>Subnet IP limit exceeded.</p> </dd> <dt>ENILimitExceeded</dt> <dd> <p>ENI limit exceeded.</p> </dd> <dt>BadPermissionsUserCredentials</dt> <dd> <p>Unable to use the Role provided.</p> </dd> <dt>InvalidBundleRobotApplication</dt> <dd> <p>Robot bundle cannot be extracted (invalid format, bundling error, or other issue).</p> </dd> <dt>InvalidBundleSimulationApplication</dt> <dd> <p>Simulation bundle cannot be extracted (invalid format, bundling error, or other issue).</p> </dd> <dt>RobotApplicationVersionMismatchedEtag</dt> <dd> <p>Etag for RobotApplication does not match value during version creation.</p> </dd> <dt>SimulationApplicationVersionMismatchedEtag</dt> <dd> <p>Etag for SimulationApplication does not match value during version creation.</p> </dd> </dl></p>
1169    #[serde(rename = "failureCode")]
1170    #[serde(skip_serializing_if = "Option::is_none")]
1171    pub failure_code: Option<String>,
1172    /// <p>Details about why the simulation job failed. For more information about troubleshooting, see <a href="https://docs.aws.amazon.com/robomaker/latest/dg/troubleshooting.html">Troubleshooting</a>.</p>
1173    #[serde(rename = "failureReason")]
1174    #[serde(skip_serializing_if = "Option::is_none")]
1175    pub failure_reason: Option<String>,
1176    /// <p>The IAM role that allows the simulation instance to call the AWS APIs that are specified in its associated policies on your behalf.</p>
1177    #[serde(rename = "iamRole")]
1178    #[serde(skip_serializing_if = "Option::is_none")]
1179    pub iam_role: Option<String>,
1180    /// <p>The time, in milliseconds since the epoch, when the simulation job was last started.</p>
1181    #[serde(rename = "lastStartedAt")]
1182    #[serde(skip_serializing_if = "Option::is_none")]
1183    pub last_started_at: Option<f64>,
1184    /// <p>The time, in milliseconds since the epoch, when the simulation job was last updated.</p>
1185    #[serde(rename = "lastUpdatedAt")]
1186    #[serde(skip_serializing_if = "Option::is_none")]
1187    pub last_updated_at: Option<f64>,
1188    /// <p>The logging configuration.</p>
1189    #[serde(rename = "loggingConfig")]
1190    #[serde(skip_serializing_if = "Option::is_none")]
1191    pub logging_config: Option<LoggingConfig>,
1192    /// <p>The maximum job duration in seconds. The value must be 8 days (691,200 seconds) or less.</p>
1193    #[serde(rename = "maxJobDurationInSeconds")]
1194    #[serde(skip_serializing_if = "Option::is_none")]
1195    pub max_job_duration_in_seconds: Option<i64>,
1196    /// <p>The name of the simulation job.</p>
1197    #[serde(rename = "name")]
1198    #[serde(skip_serializing_if = "Option::is_none")]
1199    pub name: Option<String>,
1200    /// <p>The network interface information for the simulation job.</p>
1201    #[serde(rename = "networkInterface")]
1202    #[serde(skip_serializing_if = "Option::is_none")]
1203    pub network_interface: Option<NetworkInterface>,
1204    /// <p>Location for output files generated by the simulation job.</p>
1205    #[serde(rename = "outputLocation")]
1206    #[serde(skip_serializing_if = "Option::is_none")]
1207    pub output_location: Option<OutputLocation>,
1208    /// <p>A list of robot applications.</p>
1209    #[serde(rename = "robotApplications")]
1210    #[serde(skip_serializing_if = "Option::is_none")]
1211    pub robot_applications: Option<Vec<RobotApplicationConfig>>,
1212    /// <p>A list of simulation applications.</p>
1213    #[serde(rename = "simulationApplications")]
1214    #[serde(skip_serializing_if = "Option::is_none")]
1215    pub simulation_applications: Option<Vec<SimulationApplicationConfig>>,
1216    /// <p>The simulation job execution duration in milliseconds.</p>
1217    #[serde(rename = "simulationTimeMillis")]
1218    #[serde(skip_serializing_if = "Option::is_none")]
1219    pub simulation_time_millis: Option<i64>,
1220    /// <p>The status of the simulation job.</p>
1221    #[serde(rename = "status")]
1222    #[serde(skip_serializing_if = "Option::is_none")]
1223    pub status: Option<String>,
1224    /// <p>The list of all tags added to the specified simulation job.</p>
1225    #[serde(rename = "tags")]
1226    #[serde(skip_serializing_if = "Option::is_none")]
1227    pub tags: Option<::std::collections::HashMap<String, String>>,
1228    /// <p>The VPC configuration.</p>
1229    #[serde(rename = "vpcConfig")]
1230    #[serde(skip_serializing_if = "Option::is_none")]
1231    pub vpc_config: Option<VPCConfigResponse>,
1232}
1233
1234/// <p>Information about a failed create simulation job request.</p>
1235#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1236#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1237pub struct FailedCreateSimulationJobRequest {
1238    /// <p>The time, in milliseconds since the epoch, when the simulation job batch failed.</p>
1239    #[serde(rename = "failedAt")]
1240    #[serde(skip_serializing_if = "Option::is_none")]
1241    pub failed_at: Option<f64>,
1242    /// <p>The failure code.</p>
1243    #[serde(rename = "failureCode")]
1244    #[serde(skip_serializing_if = "Option::is_none")]
1245    pub failure_code: Option<String>,
1246    /// <p>The failure reason of the simulation job request.</p>
1247    #[serde(rename = "failureReason")]
1248    #[serde(skip_serializing_if = "Option::is_none")]
1249    pub failure_reason: Option<String>,
1250    /// <p>The simulation job request.</p>
1251    #[serde(rename = "request")]
1252    #[serde(skip_serializing_if = "Option::is_none")]
1253    pub request: Option<SimulationJobRequest>,
1254}
1255
1256/// <p>Information about a filter.</p>
1257#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1258#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1259pub struct Filter {
1260    /// <p>The name of the filter.</p>
1261    #[serde(rename = "name")]
1262    #[serde(skip_serializing_if = "Option::is_none")]
1263    pub name: Option<String>,
1264    /// <p>A list of values.</p>
1265    #[serde(rename = "values")]
1266    #[serde(skip_serializing_if = "Option::is_none")]
1267    pub values: Option<Vec<String>>,
1268}
1269
1270/// <p>Information about a fleet.</p>
1271#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1272#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1273pub struct Fleet {
1274    /// <p>The Amazon Resource Name (ARN) of the fleet.</p>
1275    #[serde(rename = "arn")]
1276    #[serde(skip_serializing_if = "Option::is_none")]
1277    pub arn: Option<String>,
1278    /// <p>The time, in milliseconds since the epoch, when the fleet was created.</p>
1279    #[serde(rename = "createdAt")]
1280    #[serde(skip_serializing_if = "Option::is_none")]
1281    pub created_at: Option<f64>,
1282    /// <p>The Amazon Resource Name (ARN) of the last deployment job.</p>
1283    #[serde(rename = "lastDeploymentJob")]
1284    #[serde(skip_serializing_if = "Option::is_none")]
1285    pub last_deployment_job: Option<String>,
1286    /// <p>The status of the last fleet deployment.</p>
1287    #[serde(rename = "lastDeploymentStatus")]
1288    #[serde(skip_serializing_if = "Option::is_none")]
1289    pub last_deployment_status: Option<String>,
1290    /// <p>The time of the last deployment.</p>
1291    #[serde(rename = "lastDeploymentTime")]
1292    #[serde(skip_serializing_if = "Option::is_none")]
1293    pub last_deployment_time: Option<f64>,
1294    /// <p>The name of the fleet.</p>
1295    #[serde(rename = "name")]
1296    #[serde(skip_serializing_if = "Option::is_none")]
1297    pub name: Option<String>,
1298}
1299
1300/// <p>Information about a launch configuration.</p>
1301#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1302pub struct LaunchConfig {
1303    /// <p>The environment variables for the application launch.</p>
1304    #[serde(rename = "environmentVariables")]
1305    #[serde(skip_serializing_if = "Option::is_none")]
1306    pub environment_variables: Option<::std::collections::HashMap<String, String>>,
1307    /// <p>The launch file name.</p>
1308    #[serde(rename = "launchFile")]
1309    pub launch_file: String,
1310    /// <p>The package name.</p>
1311    #[serde(rename = "packageName")]
1312    pub package_name: String,
1313    /// <p>The port forwarding configuration.</p>
1314    #[serde(rename = "portForwardingConfig")]
1315    #[serde(skip_serializing_if = "Option::is_none")]
1316    pub port_forwarding_config: Option<PortForwardingConfig>,
1317    /// <p>Boolean indicating whether a streaming session will be configured for the application. If <code>True</code>, AWS RoboMaker will configure a connection so you can interact with your application as it is running in the simulation. You must configure and luanch the component. It must have a graphical user interface. </p>
1318    #[serde(rename = "streamUI")]
1319    #[serde(skip_serializing_if = "Option::is_none")]
1320    pub stream_ui: Option<bool>,
1321}
1322
1323#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1324#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1325pub struct ListDeploymentJobsRequest {
1326    /// <p>Optional filters to limit results.</p> <p>The filter names <code>status</code> and <code>fleetName</code> are supported. When filtering, you must use the complete value of the filtered item. You can use up to three filters, but they must be for the same named item. For example, if you are looking for items with the status <code>InProgress</code> or the status <code>Pending</code>.</p>
1327    #[serde(rename = "filters")]
1328    #[serde(skip_serializing_if = "Option::is_none")]
1329    pub filters: Option<Vec<Filter>>,
1330    /// <p>When this parameter is used, <code>ListDeploymentJobs</code> only returns <code>maxResults</code> results in a single page along with a <code>nextToken</code> response element. The remaining results of the initial request can be seen by sending another <code>ListDeploymentJobs</code> request with the returned <code>nextToken</code> value. This value can be between 1 and 200. If this parameter is not used, then <code>ListDeploymentJobs</code> returns up to 200 results and a <code>nextToken</code> value if applicable. </p>
1331    #[serde(rename = "maxResults")]
1332    #[serde(skip_serializing_if = "Option::is_none")]
1333    pub max_results: Option<i64>,
1334    /// <p>The <code>nextToken</code> value returned from a previous paginated <code>ListDeploymentJobs</code> request where <code>maxResults</code> was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the <code>nextToken</code> value. </p>
1335    #[serde(rename = "nextToken")]
1336    #[serde(skip_serializing_if = "Option::is_none")]
1337    pub next_token: Option<String>,
1338}
1339
1340#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1341#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1342pub struct ListDeploymentJobsResponse {
1343    /// <p>A list of deployment jobs that meet the criteria of the request.</p>
1344    #[serde(rename = "deploymentJobs")]
1345    #[serde(skip_serializing_if = "Option::is_none")]
1346    pub deployment_jobs: Option<Vec<DeploymentJob>>,
1347    /// <p>The <code>nextToken</code> value to include in a future <code>ListDeploymentJobs</code> request. When the results of a <code>ListDeploymentJobs</code> request exceed <code>maxResults</code>, this value can be used to retrieve the next page of results. This value is <code>null</code> when there are no more results to return. </p>
1348    #[serde(rename = "nextToken")]
1349    #[serde(skip_serializing_if = "Option::is_none")]
1350    pub next_token: Option<String>,
1351}
1352
1353#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1354#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1355pub struct ListFleetsRequest {
1356    /// <p>Optional filters to limit results.</p> <p>The filter name <code>name</code> is supported. When filtering, you must use the complete value of the filtered item. You can use up to three filters.</p>
1357    #[serde(rename = "filters")]
1358    #[serde(skip_serializing_if = "Option::is_none")]
1359    pub filters: Option<Vec<Filter>>,
1360    /// <p>When this parameter is used, <code>ListFleets</code> only returns <code>maxResults</code> results in a single page along with a <code>nextToken</code> response element. The remaining results of the initial request can be seen by sending another <code>ListFleets</code> request with the returned <code>nextToken</code> value. This value can be between 1 and 200. If this parameter is not used, then <code>ListFleets</code> returns up to 200 results and a <code>nextToken</code> value if applicable. </p>
1361    #[serde(rename = "maxResults")]
1362    #[serde(skip_serializing_if = "Option::is_none")]
1363    pub max_results: Option<i64>,
1364    /// <p><p>The <code>nextToken</code> value returned from a previous paginated <code>ListFleets</code> request where <code>maxResults</code> was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the <code>nextToken</code> value. </p> <note> <p>This token should be treated as an opaque identifier that is only used to retrieve the next items in a list and not for other programmatic purposes.</p> </note></p>
1365    #[serde(rename = "nextToken")]
1366    #[serde(skip_serializing_if = "Option::is_none")]
1367    pub next_token: Option<String>,
1368}
1369
1370#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1371#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1372pub struct ListFleetsResponse {
1373    /// <p>A list of fleet details meeting the request criteria.</p>
1374    #[serde(rename = "fleetDetails")]
1375    #[serde(skip_serializing_if = "Option::is_none")]
1376    pub fleet_details: Option<Vec<Fleet>>,
1377    /// <p>The <code>nextToken</code> value to include in a future <code>ListDeploymentJobs</code> request. When the results of a <code>ListFleets</code> request exceed <code>maxResults</code>, this value can be used to retrieve the next page of results. This value is <code>null</code> when there are no more results to return. </p>
1378    #[serde(rename = "nextToken")]
1379    #[serde(skip_serializing_if = "Option::is_none")]
1380    pub next_token: Option<String>,
1381}
1382
1383#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1384#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1385pub struct ListRobotApplicationsRequest {
1386    /// <p>Optional filters to limit results.</p> <p>The filter name <code>name</code> is supported. When filtering, you must use the complete value of the filtered item. You can use up to three filters.</p>
1387    #[serde(rename = "filters")]
1388    #[serde(skip_serializing_if = "Option::is_none")]
1389    pub filters: Option<Vec<Filter>>,
1390    /// <p>When this parameter is used, <code>ListRobotApplications</code> only returns <code>maxResults</code> results in a single page along with a <code>nextToken</code> response element. The remaining results of the initial request can be seen by sending another <code>ListRobotApplications</code> request with the returned <code>nextToken</code> value. This value can be between 1 and 100. If this parameter is not used, then <code>ListRobotApplications</code> returns up to 100 results and a <code>nextToken</code> value if applicable. </p>
1391    #[serde(rename = "maxResults")]
1392    #[serde(skip_serializing_if = "Option::is_none")]
1393    pub max_results: Option<i64>,
1394    /// <p>The <code>nextToken</code> value returned from a previous paginated <code>ListRobotApplications</code> request where <code>maxResults</code> was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the <code>nextToken</code> value. </p>
1395    #[serde(rename = "nextToken")]
1396    #[serde(skip_serializing_if = "Option::is_none")]
1397    pub next_token: Option<String>,
1398    /// <p>The version qualifier of the robot application.</p>
1399    #[serde(rename = "versionQualifier")]
1400    #[serde(skip_serializing_if = "Option::is_none")]
1401    pub version_qualifier: Option<String>,
1402}
1403
1404#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1405#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1406pub struct ListRobotApplicationsResponse {
1407    /// <p>The <code>nextToken</code> value to include in a future <code>ListRobotApplications</code> request. When the results of a <code>ListRobotApplications</code> request exceed <code>maxResults</code>, this value can be used to retrieve the next page of results. This value is <code>null</code> when there are no more results to return. </p>
1408    #[serde(rename = "nextToken")]
1409    #[serde(skip_serializing_if = "Option::is_none")]
1410    pub next_token: Option<String>,
1411    /// <p>A list of robot application summaries that meet the criteria of the request.</p>
1412    #[serde(rename = "robotApplicationSummaries")]
1413    #[serde(skip_serializing_if = "Option::is_none")]
1414    pub robot_application_summaries: Option<Vec<RobotApplicationSummary>>,
1415}
1416
1417#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1418#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1419pub struct ListRobotsRequest {
1420    /// <p>Optional filters to limit results.</p> <p>The filter names <code>status</code> and <code>fleetName</code> are supported. When filtering, you must use the complete value of the filtered item. You can use up to three filters, but they must be for the same named item. For example, if you are looking for items with the status <code>Registered</code> or the status <code>Available</code>.</p>
1421    #[serde(rename = "filters")]
1422    #[serde(skip_serializing_if = "Option::is_none")]
1423    pub filters: Option<Vec<Filter>>,
1424    /// <p>When this parameter is used, <code>ListRobots</code> only returns <code>maxResults</code> results in a single page along with a <code>nextToken</code> response element. The remaining results of the initial request can be seen by sending another <code>ListRobots</code> request with the returned <code>nextToken</code> value. This value can be between 1 and 200. If this parameter is not used, then <code>ListRobots</code> returns up to 200 results and a <code>nextToken</code> value if applicable. </p>
1425    #[serde(rename = "maxResults")]
1426    #[serde(skip_serializing_if = "Option::is_none")]
1427    pub max_results: Option<i64>,
1428    /// <p>The <code>nextToken</code> value returned from a previous paginated <code>ListRobots</code> request where <code>maxResults</code> was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the <code>nextToken</code> value. </p>
1429    #[serde(rename = "nextToken")]
1430    #[serde(skip_serializing_if = "Option::is_none")]
1431    pub next_token: Option<String>,
1432}
1433
1434#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1435#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1436pub struct ListRobotsResponse {
1437    /// <p>The <code>nextToken</code> value to include in a future <code>ListRobots</code> request. When the results of a <code>ListRobot</code> request exceed <code>maxResults</code>, this value can be used to retrieve the next page of results. This value is <code>null</code> when there are no more results to return. </p>
1438    #[serde(rename = "nextToken")]
1439    #[serde(skip_serializing_if = "Option::is_none")]
1440    pub next_token: Option<String>,
1441    /// <p>A list of robots that meet the criteria of the request.</p>
1442    #[serde(rename = "robots")]
1443    #[serde(skip_serializing_if = "Option::is_none")]
1444    pub robots: Option<Vec<Robot>>,
1445}
1446
1447#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1448#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1449pub struct ListSimulationApplicationsRequest {
1450    /// <p>Optional list of filters to limit results.</p> <p>The filter name <code>name</code> is supported. When filtering, you must use the complete value of the filtered item. You can use up to three filters.</p>
1451    #[serde(rename = "filters")]
1452    #[serde(skip_serializing_if = "Option::is_none")]
1453    pub filters: Option<Vec<Filter>>,
1454    /// <p>When this parameter is used, <code>ListSimulationApplications</code> only returns <code>maxResults</code> results in a single page along with a <code>nextToken</code> response element. The remaining results of the initial request can be seen by sending another <code>ListSimulationApplications</code> request with the returned <code>nextToken</code> value. This value can be between 1 and 100. If this parameter is not used, then <code>ListSimulationApplications</code> returns up to 100 results and a <code>nextToken</code> value if applicable. </p>
1455    #[serde(rename = "maxResults")]
1456    #[serde(skip_serializing_if = "Option::is_none")]
1457    pub max_results: Option<i64>,
1458    /// <p>The <code>nextToken</code> value returned from a previous paginated <code>ListSimulationApplications</code> request where <code>maxResults</code> was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the <code>nextToken</code> value. </p>
1459    #[serde(rename = "nextToken")]
1460    #[serde(skip_serializing_if = "Option::is_none")]
1461    pub next_token: Option<String>,
1462    /// <p>The version qualifier of the simulation application.</p>
1463    #[serde(rename = "versionQualifier")]
1464    #[serde(skip_serializing_if = "Option::is_none")]
1465    pub version_qualifier: Option<String>,
1466}
1467
1468#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1469#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1470pub struct ListSimulationApplicationsResponse {
1471    /// <p>The <code>nextToken</code> value to include in a future <code>ListSimulationApplications</code> request. When the results of a <code>ListRobot</code> request exceed <code>maxResults</code>, this value can be used to retrieve the next page of results. This value is <code>null</code> when there are no more results to return. </p>
1472    #[serde(rename = "nextToken")]
1473    #[serde(skip_serializing_if = "Option::is_none")]
1474    pub next_token: Option<String>,
1475    /// <p>A list of simulation application summaries that meet the criteria of the request.</p>
1476    #[serde(rename = "simulationApplicationSummaries")]
1477    #[serde(skip_serializing_if = "Option::is_none")]
1478    pub simulation_application_summaries: Option<Vec<SimulationApplicationSummary>>,
1479}
1480
1481#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1482#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1483pub struct ListSimulationJobBatchesRequest {
1484    /// <p>Optional filters to limit results.</p>
1485    #[serde(rename = "filters")]
1486    #[serde(skip_serializing_if = "Option::is_none")]
1487    pub filters: Option<Vec<Filter>>,
1488    /// <p>When this parameter is used, <code>ListSimulationJobBatches</code> only returns <code>maxResults</code> results in a single page along with a <code>nextToken</code> response element. The remaining results of the initial request can be seen by sending another <code>ListSimulationJobBatches</code> request with the returned <code>nextToken</code> value. </p>
1489    #[serde(rename = "maxResults")]
1490    #[serde(skip_serializing_if = "Option::is_none")]
1491    pub max_results: Option<i64>,
1492    /// <p>The <code>nextToken</code> value returned from a previous paginated <code>ListSimulationJobBatches</code> request where <code>maxResults</code> was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the <code>nextToken</code> value. </p>
1493    #[serde(rename = "nextToken")]
1494    #[serde(skip_serializing_if = "Option::is_none")]
1495    pub next_token: Option<String>,
1496}
1497
1498#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1499#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1500pub struct ListSimulationJobBatchesResponse {
1501    /// <p>The <code>nextToken</code> value to include in a future <code>ListSimulationJobBatches</code> request. When the results of a <code>ListSimulationJobBatches</code> request exceed <code>maxResults</code>, this value can be used to retrieve the next page of results. This value is <code>null</code> when there are no more results to return. </p>
1502    #[serde(rename = "nextToken")]
1503    #[serde(skip_serializing_if = "Option::is_none")]
1504    pub next_token: Option<String>,
1505    /// <p>A list of simulation job batch summaries.</p>
1506    #[serde(rename = "simulationJobBatchSummaries")]
1507    #[serde(skip_serializing_if = "Option::is_none")]
1508    pub simulation_job_batch_summaries: Option<Vec<SimulationJobBatchSummary>>,
1509}
1510
1511#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1512#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1513pub struct ListSimulationJobsRequest {
1514    /// <p>Optional filters to limit results.</p> <p>The filter names <code>status</code> and <code>simulationApplicationName</code> and <code>robotApplicationName</code> are supported. When filtering, you must use the complete value of the filtered item. You can use up to three filters, but they must be for the same named item. For example, if you are looking for items with the status <code>Preparing</code> or the status <code>Running</code>.</p>
1515    #[serde(rename = "filters")]
1516    #[serde(skip_serializing_if = "Option::is_none")]
1517    pub filters: Option<Vec<Filter>>,
1518    /// <p>When this parameter is used, <code>ListSimulationJobs</code> only returns <code>maxResults</code> results in a single page along with a <code>nextToken</code> response element. The remaining results of the initial request can be seen by sending another <code>ListSimulationJobs</code> request with the returned <code>nextToken</code> value. This value can be between 1 and 1000. If this parameter is not used, then <code>ListSimulationJobs</code> returns up to 1000 results and a <code>nextToken</code> value if applicable. </p>
1519    #[serde(rename = "maxResults")]
1520    #[serde(skip_serializing_if = "Option::is_none")]
1521    pub max_results: Option<i64>,
1522    /// <p><p>The <code>nextToken</code> value returned from a previous paginated <code>ListSimulationJobs</code> request where <code>maxResults</code> was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the <code>nextToken</code> value. </p> <note> <p>This token should be treated as an opaque identifier that is only used to retrieve the next items in a list and not for other programmatic purposes.</p> </note></p>
1523    #[serde(rename = "nextToken")]
1524    #[serde(skip_serializing_if = "Option::is_none")]
1525    pub next_token: Option<String>,
1526}
1527
1528#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1529#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1530pub struct ListSimulationJobsResponse {
1531    /// <p>The <code>nextToken</code> value to include in a future <code>ListSimulationJobs</code> request. When the results of a <code>ListRobot</code> request exceed <code>maxResults</code>, this value can be used to retrieve the next page of results. This value is <code>null</code> when there are no more results to return. </p>
1532    #[serde(rename = "nextToken")]
1533    #[serde(skip_serializing_if = "Option::is_none")]
1534    pub next_token: Option<String>,
1535    /// <p>A list of simulation job summaries that meet the criteria of the request.</p>
1536    #[serde(rename = "simulationJobSummaries")]
1537    pub simulation_job_summaries: Vec<SimulationJobSummary>,
1538}
1539
1540#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1541#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1542pub struct ListTagsForResourceRequest {
1543    /// <p>The AWS RoboMaker Amazon Resource Name (ARN) with tags to be listed.</p>
1544    #[serde(rename = "resourceArn")]
1545    pub resource_arn: String,
1546}
1547
1548#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1549#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1550pub struct ListTagsForResourceResponse {
1551    /// <p>The list of all tags added to the specified resource.</p>
1552    #[serde(rename = "tags")]
1553    #[serde(skip_serializing_if = "Option::is_none")]
1554    pub tags: Option<::std::collections::HashMap<String, String>>,
1555}
1556
1557/// <p>The logging configuration.</p>
1558#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1559pub struct LoggingConfig {
1560    /// <p>A boolean indicating whether to record all ROS topics.</p>
1561    #[serde(rename = "recordAllRosTopics")]
1562    pub record_all_ros_topics: bool,
1563}
1564
1565/// <p>Describes a network interface.</p>
1566#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1567#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1568pub struct NetworkInterface {
1569    /// <p>The ID of the network interface.</p>
1570    #[serde(rename = "networkInterfaceId")]
1571    #[serde(skip_serializing_if = "Option::is_none")]
1572    pub network_interface_id: Option<String>,
1573    /// <p>The IPv4 address of the network interface within the subnet.</p>
1574    #[serde(rename = "privateIpAddress")]
1575    #[serde(skip_serializing_if = "Option::is_none")]
1576    pub private_ip_address: Option<String>,
1577    /// <p>The IPv4 public address of the network interface.</p>
1578    #[serde(rename = "publicIpAddress")]
1579    #[serde(skip_serializing_if = "Option::is_none")]
1580    pub public_ip_address: Option<String>,
1581}
1582
1583/// <p>The output location.</p>
1584#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1585pub struct OutputLocation {
1586    /// <p>The S3 bucket for output.</p>
1587    #[serde(rename = "s3Bucket")]
1588    #[serde(skip_serializing_if = "Option::is_none")]
1589    pub s_3_bucket: Option<String>,
1590    /// <p>The S3 folder in the <code>s3Bucket</code> where output files will be placed.</p>
1591    #[serde(rename = "s3Prefix")]
1592    #[serde(skip_serializing_if = "Option::is_none")]
1593    pub s_3_prefix: Option<String>,
1594}
1595
1596/// <p>Configuration information for port forwarding.</p>
1597#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1598pub struct PortForwardingConfig {
1599    /// <p>The port mappings for the configuration.</p>
1600    #[serde(rename = "portMappings")]
1601    #[serde(skip_serializing_if = "Option::is_none")]
1602    pub port_mappings: Option<Vec<PortMapping>>,
1603}
1604
1605/// <p>An object representing a port mapping.</p>
1606#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1607pub struct PortMapping {
1608    /// <p>The port number on the application.</p>
1609    #[serde(rename = "applicationPort")]
1610    pub application_port: i64,
1611    /// <p>A Boolean indicating whether to enable this port mapping on public IP.</p>
1612    #[serde(rename = "enableOnPublicIp")]
1613    #[serde(skip_serializing_if = "Option::is_none")]
1614    pub enable_on_public_ip: Option<bool>,
1615    /// <p>The port number on the simulation job instance to use as a remote connection point. </p>
1616    #[serde(rename = "jobPort")]
1617    pub job_port: i64,
1618}
1619
1620/// <p>Information about the progress of a deployment job.</p>
1621#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1622#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1623pub struct ProgressDetail {
1624    /// <p><p>The current progress status.</p> <dl> <dt>Validating</dt> <dd> <p>Validating the deployment.</p> </dd> <dt>DownloadingExtracting</dt> <dd> <p>Downloading and extracting the bundle on the robot.</p> </dd> <dt>ExecutingPreLaunch</dt> <dd> <p>Executing pre-launch script(s) if provided.</p> </dd> <dt>Launching</dt> <dd> <p>Launching the robot application.</p> </dd> <dt>ExecutingPostLaunch</dt> <dd> <p>Executing post-launch script(s) if provided.</p> </dd> <dt>Finished</dt> <dd> <p>Deployment is complete.</p> </dd> </dl></p>
1625    #[serde(rename = "currentProgress")]
1626    #[serde(skip_serializing_if = "Option::is_none")]
1627    pub current_progress: Option<String>,
1628    /// <p>Estimated amount of time in seconds remaining in the step. This currently only applies to the <code>Downloading/Extracting</code> step of the deployment. It is empty for other steps.</p>
1629    #[serde(rename = "estimatedTimeRemainingSeconds")]
1630    #[serde(skip_serializing_if = "Option::is_none")]
1631    pub estimated_time_remaining_seconds: Option<i64>,
1632    /// <p>Precentage of the step that is done. This currently only applies to the <code>Downloading/Extracting</code> step of the deployment. It is empty for other steps.</p>
1633    #[serde(rename = "percentDone")]
1634    #[serde(skip_serializing_if = "Option::is_none")]
1635    pub percent_done: Option<f32>,
1636    /// <p>The Amazon Resource Name (ARN) of the deployment job.</p>
1637    #[serde(rename = "targetResource")]
1638    #[serde(skip_serializing_if = "Option::is_none")]
1639    pub target_resource: Option<String>,
1640}
1641
1642#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1643#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1644pub struct RegisterRobotRequest {
1645    /// <p>The Amazon Resource Name (ARN) of the fleet.</p>
1646    #[serde(rename = "fleet")]
1647    pub fleet: String,
1648    /// <p>The Amazon Resource Name (ARN) of the robot.</p>
1649    #[serde(rename = "robot")]
1650    pub robot: String,
1651}
1652
1653#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1654#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1655pub struct RegisterRobotResponse {
1656    /// <p>The Amazon Resource Name (ARN) of the fleet that the robot will join.</p>
1657    #[serde(rename = "fleet")]
1658    #[serde(skip_serializing_if = "Option::is_none")]
1659    pub fleet: Option<String>,
1660    /// <p>Information about the robot registration.</p>
1661    #[serde(rename = "robot")]
1662    #[serde(skip_serializing_if = "Option::is_none")]
1663    pub robot: Option<String>,
1664}
1665
1666/// <p>Information about a rendering engine.</p>
1667#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1668pub struct RenderingEngine {
1669    /// <p>The name of the rendering engine.</p>
1670    #[serde(rename = "name")]
1671    #[serde(skip_serializing_if = "Option::is_none")]
1672    pub name: Option<String>,
1673    /// <p>The version of the rendering engine.</p>
1674    #[serde(rename = "version")]
1675    #[serde(skip_serializing_if = "Option::is_none")]
1676    pub version: Option<String>,
1677}
1678
1679#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1680#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1681pub struct RestartSimulationJobRequest {
1682    /// <p>The Amazon Resource Name (ARN) of the simulation job.</p>
1683    #[serde(rename = "job")]
1684    pub job: String,
1685}
1686
1687#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1688#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1689pub struct RestartSimulationJobResponse {}
1690
1691/// <p>Information about a robot.</p>
1692#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1693#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1694pub struct Robot {
1695    /// <p>The architecture of the robot.</p>
1696    #[serde(rename = "architecture")]
1697    #[serde(skip_serializing_if = "Option::is_none")]
1698    pub architecture: Option<String>,
1699    /// <p>The Amazon Resource Name (ARN) of the robot.</p>
1700    #[serde(rename = "arn")]
1701    #[serde(skip_serializing_if = "Option::is_none")]
1702    pub arn: Option<String>,
1703    /// <p>The time, in milliseconds since the epoch, when the robot was created.</p>
1704    #[serde(rename = "createdAt")]
1705    #[serde(skip_serializing_if = "Option::is_none")]
1706    pub created_at: Option<f64>,
1707    /// <p>The Amazon Resource Name (ARN) of the fleet.</p>
1708    #[serde(rename = "fleetArn")]
1709    #[serde(skip_serializing_if = "Option::is_none")]
1710    pub fleet_arn: Option<String>,
1711    /// <p>The Greengrass group associated with the robot.</p>
1712    #[serde(rename = "greenGrassGroupId")]
1713    #[serde(skip_serializing_if = "Option::is_none")]
1714    pub green_grass_group_id: Option<String>,
1715    /// <p>The Amazon Resource Name (ARN) of the last deployment job.</p>
1716    #[serde(rename = "lastDeploymentJob")]
1717    #[serde(skip_serializing_if = "Option::is_none")]
1718    pub last_deployment_job: Option<String>,
1719    /// <p>The time of the last deployment.</p>
1720    #[serde(rename = "lastDeploymentTime")]
1721    #[serde(skip_serializing_if = "Option::is_none")]
1722    pub last_deployment_time: Option<f64>,
1723    /// <p>The name of the robot.</p>
1724    #[serde(rename = "name")]
1725    #[serde(skip_serializing_if = "Option::is_none")]
1726    pub name: Option<String>,
1727    /// <p>The status of the robot.</p>
1728    #[serde(rename = "status")]
1729    #[serde(skip_serializing_if = "Option::is_none")]
1730    pub status: Option<String>,
1731}
1732
1733/// <p>Application configuration information for a robot.</p>
1734#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1735pub struct RobotApplicationConfig {
1736    /// <p>The application information for the robot application.</p>
1737    #[serde(rename = "application")]
1738    pub application: String,
1739    /// <p>The version of the robot application.</p>
1740    #[serde(rename = "applicationVersion")]
1741    #[serde(skip_serializing_if = "Option::is_none")]
1742    pub application_version: Option<String>,
1743    /// <p>The launch configuration for the robot application.</p>
1744    #[serde(rename = "launchConfig")]
1745    pub launch_config: LaunchConfig,
1746}
1747
1748/// <p>Summary information for a robot application.</p>
1749#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1750#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1751pub struct RobotApplicationSummary {
1752    /// <p>The Amazon Resource Name (ARN) of the robot.</p>
1753    #[serde(rename = "arn")]
1754    #[serde(skip_serializing_if = "Option::is_none")]
1755    pub arn: Option<String>,
1756    /// <p>The time, in milliseconds since the epoch, when the robot application was last updated.</p>
1757    #[serde(rename = "lastUpdatedAt")]
1758    #[serde(skip_serializing_if = "Option::is_none")]
1759    pub last_updated_at: Option<f64>,
1760    /// <p>The name of the robot application.</p>
1761    #[serde(rename = "name")]
1762    #[serde(skip_serializing_if = "Option::is_none")]
1763    pub name: Option<String>,
1764    /// <p>Information about a robot software suite (ROS distribution).</p>
1765    #[serde(rename = "robotSoftwareSuite")]
1766    #[serde(skip_serializing_if = "Option::is_none")]
1767    pub robot_software_suite: Option<RobotSoftwareSuite>,
1768    /// <p>The version of the robot application.</p>
1769    #[serde(rename = "version")]
1770    #[serde(skip_serializing_if = "Option::is_none")]
1771    pub version: Option<String>,
1772}
1773
1774/// <p>Information about a robot deployment.</p>
1775#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1776#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1777pub struct RobotDeployment {
1778    /// <p>The robot deployment Amazon Resource Name (ARN).</p>
1779    #[serde(rename = "arn")]
1780    #[serde(skip_serializing_if = "Option::is_none")]
1781    pub arn: Option<String>,
1782    /// <p>The time, in milliseconds since the epoch, when the deployment finished.</p>
1783    #[serde(rename = "deploymentFinishTime")]
1784    #[serde(skip_serializing_if = "Option::is_none")]
1785    pub deployment_finish_time: Option<f64>,
1786    /// <p>The time, in milliseconds since the epoch, when the deployment was started.</p>
1787    #[serde(rename = "deploymentStartTime")]
1788    #[serde(skip_serializing_if = "Option::is_none")]
1789    pub deployment_start_time: Option<f64>,
1790    /// <p>The robot deployment failure code.</p>
1791    #[serde(rename = "failureCode")]
1792    #[serde(skip_serializing_if = "Option::is_none")]
1793    pub failure_code: Option<String>,
1794    /// <p>A short description of the reason why the robot deployment failed.</p>
1795    #[serde(rename = "failureReason")]
1796    #[serde(skip_serializing_if = "Option::is_none")]
1797    pub failure_reason: Option<String>,
1798    /// <p>Information about how the deployment is progressing.</p>
1799    #[serde(rename = "progressDetail")]
1800    #[serde(skip_serializing_if = "Option::is_none")]
1801    pub progress_detail: Option<ProgressDetail>,
1802    /// <p>The status of the robot deployment.</p>
1803    #[serde(rename = "status")]
1804    #[serde(skip_serializing_if = "Option::is_none")]
1805    pub status: Option<String>,
1806}
1807
1808/// <p>Information about a robot software suite (ROS distribution).</p>
1809#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1810pub struct RobotSoftwareSuite {
1811    /// <p>The name of the robot software suite (ROS distribution).</p>
1812    #[serde(rename = "name")]
1813    #[serde(skip_serializing_if = "Option::is_none")]
1814    pub name: Option<String>,
1815    /// <p>The version of the robot software suite (ROS distribution).</p>
1816    #[serde(rename = "version")]
1817    #[serde(skip_serializing_if = "Option::is_none")]
1818    pub version: Option<String>,
1819}
1820
1821/// <p>Information about S3 keys.</p>
1822#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1823#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1824pub struct S3KeyOutput {
1825    /// <p>The etag for the object.</p>
1826    #[serde(rename = "etag")]
1827    #[serde(skip_serializing_if = "Option::is_none")]
1828    pub etag: Option<String>,
1829    /// <p>The S3 key.</p>
1830    #[serde(rename = "s3Key")]
1831    #[serde(skip_serializing_if = "Option::is_none")]
1832    pub s_3_key: Option<String>,
1833}
1834
1835/// <p>Information about an S3 object.</p>
1836#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1837pub struct S3Object {
1838    /// <p>The bucket containing the object.</p>
1839    #[serde(rename = "bucket")]
1840    pub bucket: String,
1841    /// <p>The etag of the object.</p>
1842    #[serde(rename = "etag")]
1843    #[serde(skip_serializing_if = "Option::is_none")]
1844    pub etag: Option<String>,
1845    /// <p>The key of the object.</p>
1846    #[serde(rename = "key")]
1847    pub key: String,
1848}
1849
1850/// <p>Information about a simulation application configuration.</p>
1851#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1852pub struct SimulationApplicationConfig {
1853    /// <p>The application information for the simulation application.</p>
1854    #[serde(rename = "application")]
1855    pub application: String,
1856    /// <p>The version of the simulation application.</p>
1857    #[serde(rename = "applicationVersion")]
1858    #[serde(skip_serializing_if = "Option::is_none")]
1859    pub application_version: Option<String>,
1860    /// <p>The launch configuration for the simulation application.</p>
1861    #[serde(rename = "launchConfig")]
1862    pub launch_config: LaunchConfig,
1863}
1864
1865/// <p>Summary information for a simulation application.</p>
1866#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1867#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1868pub struct SimulationApplicationSummary {
1869    /// <p>The Amazon Resource Name (ARN) of the simulation application.</p>
1870    #[serde(rename = "arn")]
1871    #[serde(skip_serializing_if = "Option::is_none")]
1872    pub arn: Option<String>,
1873    /// <p>The time, in milliseconds since the epoch, when the simulation application was last updated.</p>
1874    #[serde(rename = "lastUpdatedAt")]
1875    #[serde(skip_serializing_if = "Option::is_none")]
1876    pub last_updated_at: Option<f64>,
1877    /// <p>The name of the simulation application.</p>
1878    #[serde(rename = "name")]
1879    #[serde(skip_serializing_if = "Option::is_none")]
1880    pub name: Option<String>,
1881    /// <p>Information about a robot software suite (ROS distribution).</p>
1882    #[serde(rename = "robotSoftwareSuite")]
1883    #[serde(skip_serializing_if = "Option::is_none")]
1884    pub robot_software_suite: Option<RobotSoftwareSuite>,
1885    /// <p>Information about a simulation software suite.</p>
1886    #[serde(rename = "simulationSoftwareSuite")]
1887    #[serde(skip_serializing_if = "Option::is_none")]
1888    pub simulation_software_suite: Option<SimulationSoftwareSuite>,
1889    /// <p>The version of the simulation application.</p>
1890    #[serde(rename = "version")]
1891    #[serde(skip_serializing_if = "Option::is_none")]
1892    pub version: Option<String>,
1893}
1894
1895/// <p>Information about a simulation job.</p>
1896#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1897#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1898pub struct SimulationJob {
1899    /// <p>The Amazon Resource Name (ARN) of the simulation job.</p>
1900    #[serde(rename = "arn")]
1901    #[serde(skip_serializing_if = "Option::is_none")]
1902    pub arn: Option<String>,
1903    /// <p>A unique identifier for this <code>SimulationJob</code> request.</p>
1904    #[serde(rename = "clientRequestToken")]
1905    #[serde(skip_serializing_if = "Option::is_none")]
1906    pub client_request_token: Option<String>,
1907    /// <p>Compute information for the simulation job</p>
1908    #[serde(rename = "compute")]
1909    #[serde(skip_serializing_if = "Option::is_none")]
1910    pub compute: Option<ComputeResponse>,
1911    /// <p>The data sources for the simulation job.</p>
1912    #[serde(rename = "dataSources")]
1913    #[serde(skip_serializing_if = "Option::is_none")]
1914    pub data_sources: Option<Vec<DataSource>>,
1915    /// <p><p>The failure behavior the simulation job.</p> <dl> <dt>Continue</dt> <dd> <p>Restart the simulation job in the same host instance.</p> </dd> <dt>Fail</dt> <dd> <p>Stop the simulation job and terminate the instance.</p> </dd> </dl></p>
1916    #[serde(rename = "failureBehavior")]
1917    #[serde(skip_serializing_if = "Option::is_none")]
1918    pub failure_behavior: Option<String>,
1919    /// <p>The failure code of the simulation job if it failed.</p>
1920    #[serde(rename = "failureCode")]
1921    #[serde(skip_serializing_if = "Option::is_none")]
1922    pub failure_code: Option<String>,
1923    /// <p>The reason why the simulation job failed.</p>
1924    #[serde(rename = "failureReason")]
1925    #[serde(skip_serializing_if = "Option::is_none")]
1926    pub failure_reason: Option<String>,
1927    /// <p>The IAM role that allows the simulation instance to call the AWS APIs that are specified in its associated policies on your behalf. This is how credentials are passed in to your simulation job. </p>
1928    #[serde(rename = "iamRole")]
1929    #[serde(skip_serializing_if = "Option::is_none")]
1930    pub iam_role: Option<String>,
1931    /// <p>The time, in milliseconds since the epoch, when the simulation job was last started.</p>
1932    #[serde(rename = "lastStartedAt")]
1933    #[serde(skip_serializing_if = "Option::is_none")]
1934    pub last_started_at: Option<f64>,
1935    /// <p>The time, in milliseconds since the epoch, when the simulation job was last updated.</p>
1936    #[serde(rename = "lastUpdatedAt")]
1937    #[serde(skip_serializing_if = "Option::is_none")]
1938    pub last_updated_at: Option<f64>,
1939    /// <p>The logging configuration.</p>
1940    #[serde(rename = "loggingConfig")]
1941    #[serde(skip_serializing_if = "Option::is_none")]
1942    pub logging_config: Option<LoggingConfig>,
1943    /// <p>The maximum simulation job duration in seconds. The value must be 8 days (691,200 seconds) or less.</p>
1944    #[serde(rename = "maxJobDurationInSeconds")]
1945    #[serde(skip_serializing_if = "Option::is_none")]
1946    pub max_job_duration_in_seconds: Option<i64>,
1947    /// <p>The name of the simulation job.</p>
1948    #[serde(rename = "name")]
1949    #[serde(skip_serializing_if = "Option::is_none")]
1950    pub name: Option<String>,
1951    /// <p>Information about a network interface.</p>
1952    #[serde(rename = "networkInterface")]
1953    #[serde(skip_serializing_if = "Option::is_none")]
1954    pub network_interface: Option<NetworkInterface>,
1955    /// <p>Location for output files generated by the simulation job.</p>
1956    #[serde(rename = "outputLocation")]
1957    #[serde(skip_serializing_if = "Option::is_none")]
1958    pub output_location: Option<OutputLocation>,
1959    /// <p>A list of robot applications.</p>
1960    #[serde(rename = "robotApplications")]
1961    #[serde(skip_serializing_if = "Option::is_none")]
1962    pub robot_applications: Option<Vec<RobotApplicationConfig>>,
1963    /// <p>A list of simulation applications.</p>
1964    #[serde(rename = "simulationApplications")]
1965    #[serde(skip_serializing_if = "Option::is_none")]
1966    pub simulation_applications: Option<Vec<SimulationApplicationConfig>>,
1967    /// <p>The simulation job execution duration in milliseconds.</p>
1968    #[serde(rename = "simulationTimeMillis")]
1969    #[serde(skip_serializing_if = "Option::is_none")]
1970    pub simulation_time_millis: Option<i64>,
1971    /// <p>Status of the simulation job.</p>
1972    #[serde(rename = "status")]
1973    #[serde(skip_serializing_if = "Option::is_none")]
1974    pub status: Option<String>,
1975    /// <p>A map that contains tag keys and tag values that are attached to the simulation job.</p>
1976    #[serde(rename = "tags")]
1977    #[serde(skip_serializing_if = "Option::is_none")]
1978    pub tags: Option<::std::collections::HashMap<String, String>>,
1979    /// <p>VPC configuration information.</p>
1980    #[serde(rename = "vpcConfig")]
1981    #[serde(skip_serializing_if = "Option::is_none")]
1982    pub vpc_config: Option<VPCConfigResponse>,
1983}
1984
1985/// <p>Information about a simulation job batch.</p>
1986#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1987#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1988pub struct SimulationJobBatchSummary {
1989    /// <p>The Amazon Resource Name (ARN) of the batch.</p>
1990    #[serde(rename = "arn")]
1991    #[serde(skip_serializing_if = "Option::is_none")]
1992    pub arn: Option<String>,
1993    /// <p>The time, in milliseconds since the epoch, when the simulation job batch was created.</p>
1994    #[serde(rename = "createdAt")]
1995    #[serde(skip_serializing_if = "Option::is_none")]
1996    pub created_at: Option<f64>,
1997    /// <p>The number of created simulation job requests.</p>
1998    #[serde(rename = "createdRequestCount")]
1999    #[serde(skip_serializing_if = "Option::is_none")]
2000    pub created_request_count: Option<i64>,
2001    /// <p>The number of failed simulation job requests.</p>
2002    #[serde(rename = "failedRequestCount")]
2003    #[serde(skip_serializing_if = "Option::is_none")]
2004    pub failed_request_count: Option<i64>,
2005    /// <p>The time, in milliseconds since the epoch, when the simulation job batch was last updated.</p>
2006    #[serde(rename = "lastUpdatedAt")]
2007    #[serde(skip_serializing_if = "Option::is_none")]
2008    pub last_updated_at: Option<f64>,
2009    /// <p>The number of pending simulation job requests.</p>
2010    #[serde(rename = "pendingRequestCount")]
2011    #[serde(skip_serializing_if = "Option::is_none")]
2012    pub pending_request_count: Option<i64>,
2013    /// <p><p>The status of the simulation job batch.</p> <dl> <dt>Pending</dt> <dd> <p>The simulation job batch request is pending.</p> </dd> <dt>InProgress</dt> <dd> <p>The simulation job batch is in progress. </p> </dd> <dt>Failed</dt> <dd> <p>The simulation job batch failed. One or more simulation job requests could not be completed due to an internal failure (like <code>InternalServiceError</code>). See <code>failureCode</code> and <code>failureReason</code> for more information.</p> </dd> <dt>Completed</dt> <dd> <p>The simulation batch job completed. A batch is complete when (1) there are no pending simulation job requests in the batch and none of the failed simulation job requests are due to <code>InternalServiceError</code> and (2) when all created simulation jobs have reached a terminal state (for example, <code>Completed</code> or <code>Failed</code>). </p> </dd> <dt>Canceled</dt> <dd> <p>The simulation batch job was cancelled.</p> </dd> <dt>Canceling</dt> <dd> <p>The simulation batch job is being cancelled.</p> </dd> <dt>Completing</dt> <dd> <p>The simulation batch job is completing.</p> </dd> <dt>TimingOut</dt> <dd> <p>The simulation job batch is timing out.</p> <p>If a batch timing out, and there are pending requests that were failing due to an internal failure (like <code>InternalServiceError</code>), the batch status will be <code>Failed</code>. If there are no such failing request, the batch status will be <code>TimedOut</code>. </p> </dd> <dt>TimedOut</dt> <dd> <p>The simulation batch job timed out.</p> </dd> </dl></p>
2014    #[serde(rename = "status")]
2015    #[serde(skip_serializing_if = "Option::is_none")]
2016    pub status: Option<String>,
2017}
2018
2019/// <p>Information about a simulation job request.</p>
2020#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
2021pub struct SimulationJobRequest {
2022    /// <p>Compute information for the simulation job</p>
2023    #[serde(rename = "compute")]
2024    #[serde(skip_serializing_if = "Option::is_none")]
2025    pub compute: Option<Compute>,
2026    /// <p><p>Specify data sources to mount read-only files from S3 into your simulation. These files are available under <code>/opt/robomaker/datasources/data<em>source</em>name</code>. </p> <note> <p>There is a limit of 100 files and a combined size of 25GB for all <code>DataSourceConfig</code> objects. </p> </note></p>
2027    #[serde(rename = "dataSources")]
2028    #[serde(skip_serializing_if = "Option::is_none")]
2029    pub data_sources: Option<Vec<DataSourceConfig>>,
2030    /// <p><p>The failure behavior the simulation job.</p> <dl> <dt>Continue</dt> <dd> <p>Restart the simulation job in the same host instance.</p> </dd> <dt>Fail</dt> <dd> <p>Stop the simulation job and terminate the instance.</p> </dd> </dl></p>
2031    #[serde(rename = "failureBehavior")]
2032    #[serde(skip_serializing_if = "Option::is_none")]
2033    pub failure_behavior: Option<String>,
2034    /// <p>The IAM role name that allows the simulation instance to call the AWS APIs that are specified in its associated policies on your behalf. This is how credentials are passed in to your simulation job. </p>
2035    #[serde(rename = "iamRole")]
2036    #[serde(skip_serializing_if = "Option::is_none")]
2037    pub iam_role: Option<String>,
2038    #[serde(rename = "loggingConfig")]
2039    #[serde(skip_serializing_if = "Option::is_none")]
2040    pub logging_config: Option<LoggingConfig>,
2041    /// <p>The maximum simulation job duration in seconds. The value must be 8 days (691,200 seconds) or less.</p>
2042    #[serde(rename = "maxJobDurationInSeconds")]
2043    pub max_job_duration_in_seconds: i64,
2044    #[serde(rename = "outputLocation")]
2045    #[serde(skip_serializing_if = "Option::is_none")]
2046    pub output_location: Option<OutputLocation>,
2047    /// <p>The robot applications to use in the simulation job.</p>
2048    #[serde(rename = "robotApplications")]
2049    #[serde(skip_serializing_if = "Option::is_none")]
2050    pub robot_applications: Option<Vec<RobotApplicationConfig>>,
2051    /// <p>The simulation applications to use in the simulation job.</p>
2052    #[serde(rename = "simulationApplications")]
2053    #[serde(skip_serializing_if = "Option::is_none")]
2054    pub simulation_applications: Option<Vec<SimulationApplicationConfig>>,
2055    /// <p>A map that contains tag keys and tag values that are attached to the simulation job request.</p>
2056    #[serde(rename = "tags")]
2057    #[serde(skip_serializing_if = "Option::is_none")]
2058    pub tags: Option<::std::collections::HashMap<String, String>>,
2059    /// <p>Boolean indicating whether to use default simulation tool applications.</p>
2060    #[serde(rename = "useDefaultApplications")]
2061    #[serde(skip_serializing_if = "Option::is_none")]
2062    pub use_default_applications: Option<bool>,
2063    #[serde(rename = "vpcConfig")]
2064    #[serde(skip_serializing_if = "Option::is_none")]
2065    pub vpc_config: Option<VPCConfig>,
2066}
2067
2068/// <p>Summary information for a simulation job.</p>
2069#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
2070#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
2071pub struct SimulationJobSummary {
2072    /// <p>The Amazon Resource Name (ARN) of the simulation job.</p>
2073    #[serde(rename = "arn")]
2074    #[serde(skip_serializing_if = "Option::is_none")]
2075    pub arn: Option<String>,
2076    /// <p>The names of the data sources.</p>
2077    #[serde(rename = "dataSourceNames")]
2078    #[serde(skip_serializing_if = "Option::is_none")]
2079    pub data_source_names: Option<Vec<String>>,
2080    /// <p>The time, in milliseconds since the epoch, when the simulation job was last updated.</p>
2081    #[serde(rename = "lastUpdatedAt")]
2082    #[serde(skip_serializing_if = "Option::is_none")]
2083    pub last_updated_at: Option<f64>,
2084    /// <p>The name of the simulation job.</p>
2085    #[serde(rename = "name")]
2086    #[serde(skip_serializing_if = "Option::is_none")]
2087    pub name: Option<String>,
2088    /// <p>A list of simulation job robot application names.</p>
2089    #[serde(rename = "robotApplicationNames")]
2090    #[serde(skip_serializing_if = "Option::is_none")]
2091    pub robot_application_names: Option<Vec<String>>,
2092    /// <p>A list of simulation job simulation application names.</p>
2093    #[serde(rename = "simulationApplicationNames")]
2094    #[serde(skip_serializing_if = "Option::is_none")]
2095    pub simulation_application_names: Option<Vec<String>>,
2096    /// <p>The status of the simulation job.</p>
2097    #[serde(rename = "status")]
2098    #[serde(skip_serializing_if = "Option::is_none")]
2099    pub status: Option<String>,
2100}
2101
2102/// <p>Information about a simulation software suite.</p>
2103#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
2104pub struct SimulationSoftwareSuite {
2105    /// <p>The name of the simulation software suite.</p>
2106    #[serde(rename = "name")]
2107    #[serde(skip_serializing_if = "Option::is_none")]
2108    pub name: Option<String>,
2109    /// <p>The version of the simulation software suite.</p>
2110    #[serde(rename = "version")]
2111    #[serde(skip_serializing_if = "Option::is_none")]
2112    pub version: Option<String>,
2113}
2114
2115/// <p>Information about a source.</p>
2116#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
2117#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
2118pub struct Source {
2119    /// <p>The taget processor architecture for the application.</p>
2120    #[serde(rename = "architecture")]
2121    #[serde(skip_serializing_if = "Option::is_none")]
2122    pub architecture: Option<String>,
2123    /// <p>A hash of the object specified by <code>s3Bucket</code> and <code>s3Key</code>.</p>
2124    #[serde(rename = "etag")]
2125    #[serde(skip_serializing_if = "Option::is_none")]
2126    pub etag: Option<String>,
2127    /// <p>The s3 bucket name.</p>
2128    #[serde(rename = "s3Bucket")]
2129    #[serde(skip_serializing_if = "Option::is_none")]
2130    pub s_3_bucket: Option<String>,
2131    /// <p>The s3 object key.</p>
2132    #[serde(rename = "s3Key")]
2133    #[serde(skip_serializing_if = "Option::is_none")]
2134    pub s_3_key: Option<String>,
2135}
2136
2137/// <p>Information about a source configuration.</p>
2138#[derive(Clone, Debug, Default, PartialEq, Serialize)]
2139#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
2140pub struct SourceConfig {
2141    /// <p>The target processor architecture for the application.</p>
2142    #[serde(rename = "architecture")]
2143    #[serde(skip_serializing_if = "Option::is_none")]
2144    pub architecture: Option<String>,
2145    /// <p>The Amazon S3 bucket name.</p>
2146    #[serde(rename = "s3Bucket")]
2147    #[serde(skip_serializing_if = "Option::is_none")]
2148    pub s_3_bucket: Option<String>,
2149    /// <p>The s3 object key.</p>
2150    #[serde(rename = "s3Key")]
2151    #[serde(skip_serializing_if = "Option::is_none")]
2152    pub s_3_key: Option<String>,
2153}
2154
2155#[derive(Clone, Debug, Default, PartialEq, Serialize)]
2156#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
2157pub struct StartSimulationJobBatchRequest {
2158    /// <p>The batch policy.</p>
2159    #[serde(rename = "batchPolicy")]
2160    #[serde(skip_serializing_if = "Option::is_none")]
2161    pub batch_policy: Option<BatchPolicy>,
2162    /// <p>Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.</p>
2163    #[serde(rename = "clientRequestToken")]
2164    #[serde(skip_serializing_if = "Option::is_none")]
2165    pub client_request_token: Option<String>,
2166    /// <p>A list of simulation job requests to create in the batch.</p>
2167    #[serde(rename = "createSimulationJobRequests")]
2168    pub create_simulation_job_requests: Vec<SimulationJobRequest>,
2169    /// <p>A map that contains tag keys and tag values that are attached to the deployment job batch.</p>
2170    #[serde(rename = "tags")]
2171    #[serde(skip_serializing_if = "Option::is_none")]
2172    pub tags: Option<::std::collections::HashMap<String, String>>,
2173}
2174
2175#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
2176#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
2177pub struct StartSimulationJobBatchResponse {
2178    /// <p>The Amazon Resource Name (arn) of the batch.</p>
2179    #[serde(rename = "arn")]
2180    #[serde(skip_serializing_if = "Option::is_none")]
2181    pub arn: Option<String>,
2182    /// <p>The batch policy.</p>
2183    #[serde(rename = "batchPolicy")]
2184    #[serde(skip_serializing_if = "Option::is_none")]
2185    pub batch_policy: Option<BatchPolicy>,
2186    /// <p>Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.</p>
2187    #[serde(rename = "clientRequestToken")]
2188    #[serde(skip_serializing_if = "Option::is_none")]
2189    pub client_request_token: Option<String>,
2190    /// <p>The time, in milliseconds since the epoch, when the simulation job batch was created.</p>
2191    #[serde(rename = "createdAt")]
2192    #[serde(skip_serializing_if = "Option::is_none")]
2193    pub created_at: Option<f64>,
2194    /// <p>A list of created simulation job request summaries.</p>
2195    #[serde(rename = "createdRequests")]
2196    #[serde(skip_serializing_if = "Option::is_none")]
2197    pub created_requests: Option<Vec<SimulationJobSummary>>,
2198    /// <p>A list of failed simulation job requests. The request failed to be created into a simulation job. Failed requests do not have a simulation job ID. </p>
2199    #[serde(rename = "failedRequests")]
2200    #[serde(skip_serializing_if = "Option::is_none")]
2201    pub failed_requests: Option<Vec<FailedCreateSimulationJobRequest>>,
2202    /// <p>The failure code if the simulation job batch failed.</p>
2203    #[serde(rename = "failureCode")]
2204    #[serde(skip_serializing_if = "Option::is_none")]
2205    pub failure_code: Option<String>,
2206    /// <p>The reason the simulation job batch failed.</p>
2207    #[serde(rename = "failureReason")]
2208    #[serde(skip_serializing_if = "Option::is_none")]
2209    pub failure_reason: Option<String>,
2210    /// <p>A list of pending simulation job requests. These requests have not yet been created into simulation jobs.</p>
2211    #[serde(rename = "pendingRequests")]
2212    #[serde(skip_serializing_if = "Option::is_none")]
2213    pub pending_requests: Option<Vec<SimulationJobRequest>>,
2214    /// <p><p>The status of the simulation job batch.</p> <dl> <dt>Pending</dt> <dd> <p>The simulation job batch request is pending.</p> </dd> <dt>InProgress</dt> <dd> <p>The simulation job batch is in progress. </p> </dd> <dt>Failed</dt> <dd> <p>The simulation job batch failed. One or more simulation job requests could not be completed due to an internal failure (like <code>InternalServiceError</code>). See <code>failureCode</code> and <code>failureReason</code> for more information.</p> </dd> <dt>Completed</dt> <dd> <p>The simulation batch job completed. A batch is complete when (1) there are no pending simulation job requests in the batch and none of the failed simulation job requests are due to <code>InternalServiceError</code> and (2) when all created simulation jobs have reached a terminal state (for example, <code>Completed</code> or <code>Failed</code>). </p> </dd> <dt>Canceled</dt> <dd> <p>The simulation batch job was cancelled.</p> </dd> <dt>Canceling</dt> <dd> <p>The simulation batch job is being cancelled.</p> </dd> <dt>Completing</dt> <dd> <p>The simulation batch job is completing.</p> </dd> <dt>TimingOut</dt> <dd> <p>The simulation job batch is timing out.</p> <p>If a batch timing out, and there are pending requests that were failing due to an internal failure (like <code>InternalServiceError</code>), the batch status will be <code>Failed</code>. If there are no such failing request, the batch status will be <code>TimedOut</code>. </p> </dd> <dt>TimedOut</dt> <dd> <p>The simulation batch job timed out.</p> </dd> </dl></p>
2215    #[serde(rename = "status")]
2216    #[serde(skip_serializing_if = "Option::is_none")]
2217    pub status: Option<String>,
2218    /// <p>A map that contains tag keys and tag values that are attached to the deployment job batch.</p>
2219    #[serde(rename = "tags")]
2220    #[serde(skip_serializing_if = "Option::is_none")]
2221    pub tags: Option<::std::collections::HashMap<String, String>>,
2222}
2223
2224#[derive(Clone, Debug, Default, PartialEq, Serialize)]
2225#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
2226pub struct SyncDeploymentJobRequest {
2227    /// <p>Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.</p>
2228    #[serde(rename = "clientRequestToken")]
2229    pub client_request_token: String,
2230    /// <p>The target fleet for the synchronization.</p>
2231    #[serde(rename = "fleet")]
2232    pub fleet: String,
2233}
2234
2235#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
2236#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
2237pub struct SyncDeploymentJobResponse {
2238    /// <p>The Amazon Resource Name (ARN) of the synchronization request.</p>
2239    #[serde(rename = "arn")]
2240    #[serde(skip_serializing_if = "Option::is_none")]
2241    pub arn: Option<String>,
2242    /// <p>The time, in milliseconds since the epoch, when the fleet was created.</p>
2243    #[serde(rename = "createdAt")]
2244    #[serde(skip_serializing_if = "Option::is_none")]
2245    pub created_at: Option<f64>,
2246    /// <p>Information about the deployment application configurations.</p>
2247    #[serde(rename = "deploymentApplicationConfigs")]
2248    #[serde(skip_serializing_if = "Option::is_none")]
2249    pub deployment_application_configs: Option<Vec<DeploymentApplicationConfig>>,
2250    /// <p>Information about the deployment configuration.</p>
2251    #[serde(rename = "deploymentConfig")]
2252    #[serde(skip_serializing_if = "Option::is_none")]
2253    pub deployment_config: Option<DeploymentConfig>,
2254    /// <p><p>The failure code if the job fails:</p> <dl> <dt>InternalServiceError</dt> <dd> <p>Internal service error.</p> </dd> <dt>RobotApplicationCrash</dt> <dd> <p>Robot application exited abnormally.</p> </dd> <dt>SimulationApplicationCrash</dt> <dd> <p> Simulation application exited abnormally.</p> </dd> <dt>BadPermissionsRobotApplication</dt> <dd> <p>Robot application bundle could not be downloaded.</p> </dd> <dt>BadPermissionsSimulationApplication</dt> <dd> <p>Simulation application bundle could not be downloaded.</p> </dd> <dt>BadPermissionsS3Output</dt> <dd> <p>Unable to publish outputs to customer-provided S3 bucket.</p> </dd> <dt>BadPermissionsCloudwatchLogs</dt> <dd> <p>Unable to publish logs to customer-provided CloudWatch Logs resource.</p> </dd> <dt>SubnetIpLimitExceeded</dt> <dd> <p>Subnet IP limit exceeded.</p> </dd> <dt>ENILimitExceeded</dt> <dd> <p>ENI limit exceeded.</p> </dd> <dt>BadPermissionsUserCredentials</dt> <dd> <p>Unable to use the Role provided.</p> </dd> <dt>InvalidBundleRobotApplication</dt> <dd> <p>Robot bundle cannot be extracted (invalid format, bundling error, or other issue).</p> </dd> <dt>InvalidBundleSimulationApplication</dt> <dd> <p>Simulation bundle cannot be extracted (invalid format, bundling error, or other issue).</p> </dd> <dt>RobotApplicationVersionMismatchedEtag</dt> <dd> <p>Etag for RobotApplication does not match value during version creation.</p> </dd> <dt>SimulationApplicationVersionMismatchedEtag</dt> <dd> <p>Etag for SimulationApplication does not match value during version creation.</p> </dd> </dl></p>
2255    #[serde(rename = "failureCode")]
2256    #[serde(skip_serializing_if = "Option::is_none")]
2257    pub failure_code: Option<String>,
2258    /// <p>The failure reason if the job fails.</p>
2259    #[serde(rename = "failureReason")]
2260    #[serde(skip_serializing_if = "Option::is_none")]
2261    pub failure_reason: Option<String>,
2262    /// <p>The Amazon Resource Name (ARN) of the fleet.</p>
2263    #[serde(rename = "fleet")]
2264    #[serde(skip_serializing_if = "Option::is_none")]
2265    pub fleet: Option<String>,
2266    /// <p>The status of the synchronization job.</p>
2267    #[serde(rename = "status")]
2268    #[serde(skip_serializing_if = "Option::is_none")]
2269    pub status: Option<String>,
2270}
2271
2272#[derive(Clone, Debug, Default, PartialEq, Serialize)]
2273#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
2274pub struct TagResourceRequest {
2275    /// <p>The Amazon Resource Name (ARN) of the AWS RoboMaker resource you are tagging.</p>
2276    #[serde(rename = "resourceArn")]
2277    pub resource_arn: String,
2278    /// <p>A map that contains tag keys and tag values that are attached to the resource.</p>
2279    #[serde(rename = "tags")]
2280    pub tags: ::std::collections::HashMap<String, String>,
2281}
2282
2283#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
2284#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
2285pub struct TagResourceResponse {}
2286
2287#[derive(Clone, Debug, Default, PartialEq, Serialize)]
2288#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
2289pub struct UntagResourceRequest {
2290    /// <p>The Amazon Resource Name (ARN) of the AWS RoboMaker resource you are removing tags.</p>
2291    #[serde(rename = "resourceArn")]
2292    pub resource_arn: String,
2293    /// <p>A map that contains tag keys and tag values that will be unattached from the resource.</p>
2294    #[serde(rename = "tagKeys")]
2295    pub tag_keys: Vec<String>,
2296}
2297
2298#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
2299#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
2300pub struct UntagResourceResponse {}
2301
2302#[derive(Clone, Debug, Default, PartialEq, Serialize)]
2303#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
2304pub struct UpdateRobotApplicationRequest {
2305    /// <p>The application information for the robot application.</p>
2306    #[serde(rename = "application")]
2307    pub application: String,
2308    /// <p>The revision id for the robot application.</p>
2309    #[serde(rename = "currentRevisionId")]
2310    #[serde(skip_serializing_if = "Option::is_none")]
2311    pub current_revision_id: Option<String>,
2312    /// <p>The robot software suite (ROS distribution) used by the robot application.</p>
2313    #[serde(rename = "robotSoftwareSuite")]
2314    pub robot_software_suite: RobotSoftwareSuite,
2315    /// <p>The sources of the robot application.</p>
2316    #[serde(rename = "sources")]
2317    pub sources: Vec<SourceConfig>,
2318}
2319
2320#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
2321#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
2322pub struct UpdateRobotApplicationResponse {
2323    /// <p>The Amazon Resource Name (ARN) of the updated robot application.</p>
2324    #[serde(rename = "arn")]
2325    #[serde(skip_serializing_if = "Option::is_none")]
2326    pub arn: Option<String>,
2327    /// <p>The time, in milliseconds since the epoch, when the robot application was last updated.</p>
2328    #[serde(rename = "lastUpdatedAt")]
2329    #[serde(skip_serializing_if = "Option::is_none")]
2330    pub last_updated_at: Option<f64>,
2331    /// <p>The name of the robot application.</p>
2332    #[serde(rename = "name")]
2333    #[serde(skip_serializing_if = "Option::is_none")]
2334    pub name: Option<String>,
2335    /// <p>The revision id of the robot application.</p>
2336    #[serde(rename = "revisionId")]
2337    #[serde(skip_serializing_if = "Option::is_none")]
2338    pub revision_id: Option<String>,
2339    /// <p>The robot software suite (ROS distribution) used by the robot application.</p>
2340    #[serde(rename = "robotSoftwareSuite")]
2341    #[serde(skip_serializing_if = "Option::is_none")]
2342    pub robot_software_suite: Option<RobotSoftwareSuite>,
2343    /// <p>The sources of the robot application.</p>
2344    #[serde(rename = "sources")]
2345    #[serde(skip_serializing_if = "Option::is_none")]
2346    pub sources: Option<Vec<Source>>,
2347    /// <p>The version of the robot application.</p>
2348    #[serde(rename = "version")]
2349    #[serde(skip_serializing_if = "Option::is_none")]
2350    pub version: Option<String>,
2351}
2352
2353#[derive(Clone, Debug, Default, PartialEq, Serialize)]
2354#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
2355pub struct UpdateSimulationApplicationRequest {
2356    /// <p>The application information for the simulation application.</p>
2357    #[serde(rename = "application")]
2358    pub application: String,
2359    /// <p>The revision id for the robot application.</p>
2360    #[serde(rename = "currentRevisionId")]
2361    #[serde(skip_serializing_if = "Option::is_none")]
2362    pub current_revision_id: Option<String>,
2363    /// <p>The rendering engine for the simulation application.</p>
2364    #[serde(rename = "renderingEngine")]
2365    #[serde(skip_serializing_if = "Option::is_none")]
2366    pub rendering_engine: Option<RenderingEngine>,
2367    /// <p>Information about the robot software suite (ROS distribution).</p>
2368    #[serde(rename = "robotSoftwareSuite")]
2369    pub robot_software_suite: RobotSoftwareSuite,
2370    /// <p>The simulation software suite used by the simulation application.</p>
2371    #[serde(rename = "simulationSoftwareSuite")]
2372    pub simulation_software_suite: SimulationSoftwareSuite,
2373    /// <p>The sources of the simulation application.</p>
2374    #[serde(rename = "sources")]
2375    pub sources: Vec<SourceConfig>,
2376}
2377
2378#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
2379#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
2380pub struct UpdateSimulationApplicationResponse {
2381    /// <p>The Amazon Resource Name (ARN) of the updated simulation application.</p>
2382    #[serde(rename = "arn")]
2383    #[serde(skip_serializing_if = "Option::is_none")]
2384    pub arn: Option<String>,
2385    /// <p>The time, in milliseconds since the epoch, when the simulation application was last updated.</p>
2386    #[serde(rename = "lastUpdatedAt")]
2387    #[serde(skip_serializing_if = "Option::is_none")]
2388    pub last_updated_at: Option<f64>,
2389    /// <p>The name of the simulation application.</p>
2390    #[serde(rename = "name")]
2391    #[serde(skip_serializing_if = "Option::is_none")]
2392    pub name: Option<String>,
2393    /// <p>The rendering engine for the simulation application.</p>
2394    #[serde(rename = "renderingEngine")]
2395    #[serde(skip_serializing_if = "Option::is_none")]
2396    pub rendering_engine: Option<RenderingEngine>,
2397    /// <p>The revision id of the simulation application.</p>
2398    #[serde(rename = "revisionId")]
2399    #[serde(skip_serializing_if = "Option::is_none")]
2400    pub revision_id: Option<String>,
2401    /// <p>Information about the robot software suite (ROS distribution).</p>
2402    #[serde(rename = "robotSoftwareSuite")]
2403    #[serde(skip_serializing_if = "Option::is_none")]
2404    pub robot_software_suite: Option<RobotSoftwareSuite>,
2405    /// <p>The simulation software suite used by the simulation application.</p>
2406    #[serde(rename = "simulationSoftwareSuite")]
2407    #[serde(skip_serializing_if = "Option::is_none")]
2408    pub simulation_software_suite: Option<SimulationSoftwareSuite>,
2409    /// <p>The sources of the simulation application.</p>
2410    #[serde(rename = "sources")]
2411    #[serde(skip_serializing_if = "Option::is_none")]
2412    pub sources: Option<Vec<Source>>,
2413    /// <p>The version of the robot application.</p>
2414    #[serde(rename = "version")]
2415    #[serde(skip_serializing_if = "Option::is_none")]
2416    pub version: Option<String>,
2417}
2418
2419/// <p>If your simulation job accesses resources in a VPC, you provide this parameter identifying the list of security group IDs and subnet IDs. These must belong to the same VPC. You must provide at least one security group and two subnet IDs.</p>
2420#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
2421pub struct VPCConfig {
2422    /// <p>A boolean indicating whether to assign a public IP address.</p>
2423    #[serde(rename = "assignPublicIp")]
2424    #[serde(skip_serializing_if = "Option::is_none")]
2425    pub assign_public_ip: Option<bool>,
2426    /// <p>A list of one or more security groups IDs in your VPC.</p>
2427    #[serde(rename = "securityGroups")]
2428    #[serde(skip_serializing_if = "Option::is_none")]
2429    pub security_groups: Option<Vec<String>>,
2430    /// <p>A list of one or more subnet IDs in your VPC.</p>
2431    #[serde(rename = "subnets")]
2432    pub subnets: Vec<String>,
2433}
2434
2435/// <p>VPC configuration associated with your simulation job.</p>
2436#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
2437#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
2438pub struct VPCConfigResponse {
2439    /// <p>A boolean indicating if a public IP was assigned.</p>
2440    #[serde(rename = "assignPublicIp")]
2441    #[serde(skip_serializing_if = "Option::is_none")]
2442    pub assign_public_ip: Option<bool>,
2443    /// <p>A list of security group IDs associated with the simulation job.</p>
2444    #[serde(rename = "securityGroups")]
2445    #[serde(skip_serializing_if = "Option::is_none")]
2446    pub security_groups: Option<Vec<String>>,
2447    /// <p>A list of subnet IDs associated with the simulation job.</p>
2448    #[serde(rename = "subnets")]
2449    #[serde(skip_serializing_if = "Option::is_none")]
2450    pub subnets: Option<Vec<String>>,
2451    /// <p>The VPC ID associated with your simulation job.</p>
2452    #[serde(rename = "vpcId")]
2453    #[serde(skip_serializing_if = "Option::is_none")]
2454    pub vpc_id: Option<String>,
2455}
2456
2457/// Errors returned by BatchDescribeSimulationJob
2458#[derive(Debug, PartialEq)]
2459pub enum BatchDescribeSimulationJobError {
2460    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
2461    InternalServer(String),
2462    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
2463    InvalidParameter(String),
2464    /// <p>The specified resource does not exist.</p>
2465    ResourceNotFound(String),
2466    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
2467    Throttling(String),
2468}
2469
2470impl BatchDescribeSimulationJobError {
2471    pub fn from_response(
2472        res: BufferedHttpResponse,
2473    ) -> RusotoError<BatchDescribeSimulationJobError> {
2474        if let Some(err) = proto::json::Error::parse_rest(&res) {
2475            match err.typ.as_str() {
2476                "InternalServerException" => {
2477                    return RusotoError::Service(BatchDescribeSimulationJobError::InternalServer(
2478                        err.msg,
2479                    ))
2480                }
2481                "InvalidParameterException" => {
2482                    return RusotoError::Service(BatchDescribeSimulationJobError::InvalidParameter(
2483                        err.msg,
2484                    ))
2485                }
2486                "ResourceNotFoundException" => {
2487                    return RusotoError::Service(BatchDescribeSimulationJobError::ResourceNotFound(
2488                        err.msg,
2489                    ))
2490                }
2491                "ThrottlingException" => {
2492                    return RusotoError::Service(BatchDescribeSimulationJobError::Throttling(
2493                        err.msg,
2494                    ))
2495                }
2496                "ValidationException" => return RusotoError::Validation(err.msg),
2497                _ => {}
2498            }
2499        }
2500        RusotoError::Unknown(res)
2501    }
2502}
2503impl fmt::Display for BatchDescribeSimulationJobError {
2504    #[allow(unused_variables)]
2505    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2506        match *self {
2507            BatchDescribeSimulationJobError::InternalServer(ref cause) => write!(f, "{}", cause),
2508            BatchDescribeSimulationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2509            BatchDescribeSimulationJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
2510            BatchDescribeSimulationJobError::Throttling(ref cause) => write!(f, "{}", cause),
2511        }
2512    }
2513}
2514impl Error for BatchDescribeSimulationJobError {}
2515/// Errors returned by CancelDeploymentJob
2516#[derive(Debug, PartialEq)]
2517pub enum CancelDeploymentJobError {
2518    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
2519    InternalServer(String),
2520    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
2521    InvalidParameter(String),
2522    /// <p>The specified resource does not exist.</p>
2523    ResourceNotFound(String),
2524    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
2525    Throttling(String),
2526}
2527
2528impl CancelDeploymentJobError {
2529    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelDeploymentJobError> {
2530        if let Some(err) = proto::json::Error::parse_rest(&res) {
2531            match err.typ.as_str() {
2532                "InternalServerException" => {
2533                    return RusotoError::Service(CancelDeploymentJobError::InternalServer(err.msg))
2534                }
2535                "InvalidParameterException" => {
2536                    return RusotoError::Service(CancelDeploymentJobError::InvalidParameter(
2537                        err.msg,
2538                    ))
2539                }
2540                "ResourceNotFoundException" => {
2541                    return RusotoError::Service(CancelDeploymentJobError::ResourceNotFound(
2542                        err.msg,
2543                    ))
2544                }
2545                "ThrottlingException" => {
2546                    return RusotoError::Service(CancelDeploymentJobError::Throttling(err.msg))
2547                }
2548                "ValidationException" => return RusotoError::Validation(err.msg),
2549                _ => {}
2550            }
2551        }
2552        RusotoError::Unknown(res)
2553    }
2554}
2555impl fmt::Display for CancelDeploymentJobError {
2556    #[allow(unused_variables)]
2557    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2558        match *self {
2559            CancelDeploymentJobError::InternalServer(ref cause) => write!(f, "{}", cause),
2560            CancelDeploymentJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2561            CancelDeploymentJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
2562            CancelDeploymentJobError::Throttling(ref cause) => write!(f, "{}", cause),
2563        }
2564    }
2565}
2566impl Error for CancelDeploymentJobError {}
2567/// Errors returned by CancelSimulationJob
2568#[derive(Debug, PartialEq)]
2569pub enum CancelSimulationJobError {
2570    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
2571    InternalServer(String),
2572    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
2573    InvalidParameter(String),
2574    /// <p>The specified resource does not exist.</p>
2575    ResourceNotFound(String),
2576    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
2577    Throttling(String),
2578}
2579
2580impl CancelSimulationJobError {
2581    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelSimulationJobError> {
2582        if let Some(err) = proto::json::Error::parse_rest(&res) {
2583            match err.typ.as_str() {
2584                "InternalServerException" => {
2585                    return RusotoError::Service(CancelSimulationJobError::InternalServer(err.msg))
2586                }
2587                "InvalidParameterException" => {
2588                    return RusotoError::Service(CancelSimulationJobError::InvalidParameter(
2589                        err.msg,
2590                    ))
2591                }
2592                "ResourceNotFoundException" => {
2593                    return RusotoError::Service(CancelSimulationJobError::ResourceNotFound(
2594                        err.msg,
2595                    ))
2596                }
2597                "ThrottlingException" => {
2598                    return RusotoError::Service(CancelSimulationJobError::Throttling(err.msg))
2599                }
2600                "ValidationException" => return RusotoError::Validation(err.msg),
2601                _ => {}
2602            }
2603        }
2604        RusotoError::Unknown(res)
2605    }
2606}
2607impl fmt::Display for CancelSimulationJobError {
2608    #[allow(unused_variables)]
2609    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2610        match *self {
2611            CancelSimulationJobError::InternalServer(ref cause) => write!(f, "{}", cause),
2612            CancelSimulationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2613            CancelSimulationJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
2614            CancelSimulationJobError::Throttling(ref cause) => write!(f, "{}", cause),
2615        }
2616    }
2617}
2618impl Error for CancelSimulationJobError {}
2619/// Errors returned by CancelSimulationJobBatch
2620#[derive(Debug, PartialEq)]
2621pub enum CancelSimulationJobBatchError {
2622    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
2623    InternalServer(String),
2624    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
2625    InvalidParameter(String),
2626    /// <p>The specified resource does not exist.</p>
2627    ResourceNotFound(String),
2628    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
2629    Throttling(String),
2630}
2631
2632impl CancelSimulationJobBatchError {
2633    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelSimulationJobBatchError> {
2634        if let Some(err) = proto::json::Error::parse_rest(&res) {
2635            match err.typ.as_str() {
2636                "InternalServerException" => {
2637                    return RusotoError::Service(CancelSimulationJobBatchError::InternalServer(
2638                        err.msg,
2639                    ))
2640                }
2641                "InvalidParameterException" => {
2642                    return RusotoError::Service(CancelSimulationJobBatchError::InvalidParameter(
2643                        err.msg,
2644                    ))
2645                }
2646                "ResourceNotFoundException" => {
2647                    return RusotoError::Service(CancelSimulationJobBatchError::ResourceNotFound(
2648                        err.msg,
2649                    ))
2650                }
2651                "ThrottlingException" => {
2652                    return RusotoError::Service(CancelSimulationJobBatchError::Throttling(err.msg))
2653                }
2654                "ValidationException" => return RusotoError::Validation(err.msg),
2655                _ => {}
2656            }
2657        }
2658        RusotoError::Unknown(res)
2659    }
2660}
2661impl fmt::Display for CancelSimulationJobBatchError {
2662    #[allow(unused_variables)]
2663    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2664        match *self {
2665            CancelSimulationJobBatchError::InternalServer(ref cause) => write!(f, "{}", cause),
2666            CancelSimulationJobBatchError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2667            CancelSimulationJobBatchError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
2668            CancelSimulationJobBatchError::Throttling(ref cause) => write!(f, "{}", cause),
2669        }
2670    }
2671}
2672impl Error for CancelSimulationJobBatchError {}
2673/// Errors returned by CreateDeploymentJob
2674#[derive(Debug, PartialEq)]
2675pub enum CreateDeploymentJobError {
2676    /// <p>The failure percentage threshold percentage was met.</p>
2677    ConcurrentDeployment(String),
2678    /// <p>The request uses the same client token as a previous, but non-identical request. Do not reuse a client token with different requests, unless the requests are identical. </p>
2679    IdempotentParameterMismatch(String),
2680    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
2681    InternalServer(String),
2682    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
2683    InvalidParameter(String),
2684    /// <p>The requested resource exceeds the maximum number allowed, or the number of concurrent stream requests exceeds the maximum number allowed. </p>
2685    LimitExceeded(String),
2686    /// <p>The specified resource does not exist.</p>
2687    ResourceNotFound(String),
2688    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
2689    Throttling(String),
2690}
2691
2692impl CreateDeploymentJobError {
2693    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDeploymentJobError> {
2694        if let Some(err) = proto::json::Error::parse_rest(&res) {
2695            match err.typ.as_str() {
2696                "ConcurrentDeploymentException" => {
2697                    return RusotoError::Service(CreateDeploymentJobError::ConcurrentDeployment(
2698                        err.msg,
2699                    ))
2700                }
2701                "IdempotentParameterMismatchException" => {
2702                    return RusotoError::Service(
2703                        CreateDeploymentJobError::IdempotentParameterMismatch(err.msg),
2704                    )
2705                }
2706                "InternalServerException" => {
2707                    return RusotoError::Service(CreateDeploymentJobError::InternalServer(err.msg))
2708                }
2709                "InvalidParameterException" => {
2710                    return RusotoError::Service(CreateDeploymentJobError::InvalidParameter(
2711                        err.msg,
2712                    ))
2713                }
2714                "LimitExceededException" => {
2715                    return RusotoError::Service(CreateDeploymentJobError::LimitExceeded(err.msg))
2716                }
2717                "ResourceNotFoundException" => {
2718                    return RusotoError::Service(CreateDeploymentJobError::ResourceNotFound(
2719                        err.msg,
2720                    ))
2721                }
2722                "ThrottlingException" => {
2723                    return RusotoError::Service(CreateDeploymentJobError::Throttling(err.msg))
2724                }
2725                "ValidationException" => return RusotoError::Validation(err.msg),
2726                _ => {}
2727            }
2728        }
2729        RusotoError::Unknown(res)
2730    }
2731}
2732impl fmt::Display for CreateDeploymentJobError {
2733    #[allow(unused_variables)]
2734    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2735        match *self {
2736            CreateDeploymentJobError::ConcurrentDeployment(ref cause) => write!(f, "{}", cause),
2737            CreateDeploymentJobError::IdempotentParameterMismatch(ref cause) => {
2738                write!(f, "{}", cause)
2739            }
2740            CreateDeploymentJobError::InternalServer(ref cause) => write!(f, "{}", cause),
2741            CreateDeploymentJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2742            CreateDeploymentJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
2743            CreateDeploymentJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
2744            CreateDeploymentJobError::Throttling(ref cause) => write!(f, "{}", cause),
2745        }
2746    }
2747}
2748impl Error for CreateDeploymentJobError {}
2749/// Errors returned by CreateFleet
2750#[derive(Debug, PartialEq)]
2751pub enum CreateFleetError {
2752    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
2753    InternalServer(String),
2754    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
2755    InvalidParameter(String),
2756    /// <p>The requested resource exceeds the maximum number allowed, or the number of concurrent stream requests exceeds the maximum number allowed. </p>
2757    LimitExceeded(String),
2758    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
2759    Throttling(String),
2760}
2761
2762impl CreateFleetError {
2763    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateFleetError> {
2764        if let Some(err) = proto::json::Error::parse_rest(&res) {
2765            match err.typ.as_str() {
2766                "InternalServerException" => {
2767                    return RusotoError::Service(CreateFleetError::InternalServer(err.msg))
2768                }
2769                "InvalidParameterException" => {
2770                    return RusotoError::Service(CreateFleetError::InvalidParameter(err.msg))
2771                }
2772                "LimitExceededException" => {
2773                    return RusotoError::Service(CreateFleetError::LimitExceeded(err.msg))
2774                }
2775                "ThrottlingException" => {
2776                    return RusotoError::Service(CreateFleetError::Throttling(err.msg))
2777                }
2778                "ValidationException" => return RusotoError::Validation(err.msg),
2779                _ => {}
2780            }
2781        }
2782        RusotoError::Unknown(res)
2783    }
2784}
2785impl fmt::Display for CreateFleetError {
2786    #[allow(unused_variables)]
2787    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2788        match *self {
2789            CreateFleetError::InternalServer(ref cause) => write!(f, "{}", cause),
2790            CreateFleetError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2791            CreateFleetError::LimitExceeded(ref cause) => write!(f, "{}", cause),
2792            CreateFleetError::Throttling(ref cause) => write!(f, "{}", cause),
2793        }
2794    }
2795}
2796impl Error for CreateFleetError {}
2797/// Errors returned by CreateRobot
2798#[derive(Debug, PartialEq)]
2799pub enum CreateRobotError {
2800    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
2801    InternalServer(String),
2802    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
2803    InvalidParameter(String),
2804    /// <p>The requested resource exceeds the maximum number allowed, or the number of concurrent stream requests exceeds the maximum number allowed. </p>
2805    LimitExceeded(String),
2806    /// <p>The specified resource already exists.</p>
2807    ResourceAlreadyExists(String),
2808    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
2809    Throttling(String),
2810}
2811
2812impl CreateRobotError {
2813    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateRobotError> {
2814        if let Some(err) = proto::json::Error::parse_rest(&res) {
2815            match err.typ.as_str() {
2816                "InternalServerException" => {
2817                    return RusotoError::Service(CreateRobotError::InternalServer(err.msg))
2818                }
2819                "InvalidParameterException" => {
2820                    return RusotoError::Service(CreateRobotError::InvalidParameter(err.msg))
2821                }
2822                "LimitExceededException" => {
2823                    return RusotoError::Service(CreateRobotError::LimitExceeded(err.msg))
2824                }
2825                "ResourceAlreadyExistsException" => {
2826                    return RusotoError::Service(CreateRobotError::ResourceAlreadyExists(err.msg))
2827                }
2828                "ThrottlingException" => {
2829                    return RusotoError::Service(CreateRobotError::Throttling(err.msg))
2830                }
2831                "ValidationException" => return RusotoError::Validation(err.msg),
2832                _ => {}
2833            }
2834        }
2835        RusotoError::Unknown(res)
2836    }
2837}
2838impl fmt::Display for CreateRobotError {
2839    #[allow(unused_variables)]
2840    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2841        match *self {
2842            CreateRobotError::InternalServer(ref cause) => write!(f, "{}", cause),
2843            CreateRobotError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2844            CreateRobotError::LimitExceeded(ref cause) => write!(f, "{}", cause),
2845            CreateRobotError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
2846            CreateRobotError::Throttling(ref cause) => write!(f, "{}", cause),
2847        }
2848    }
2849}
2850impl Error for CreateRobotError {}
2851/// Errors returned by CreateRobotApplication
2852#[derive(Debug, PartialEq)]
2853pub enum CreateRobotApplicationError {
2854    /// <p>The request uses the same client token as a previous, but non-identical request. Do not reuse a client token with different requests, unless the requests are identical. </p>
2855    IdempotentParameterMismatch(String),
2856    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
2857    InternalServer(String),
2858    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
2859    InvalidParameter(String),
2860    /// <p>The requested resource exceeds the maximum number allowed, or the number of concurrent stream requests exceeds the maximum number allowed. </p>
2861    LimitExceeded(String),
2862    /// <p>The specified resource already exists.</p>
2863    ResourceAlreadyExists(String),
2864    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
2865    Throttling(String),
2866}
2867
2868impl CreateRobotApplicationError {
2869    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateRobotApplicationError> {
2870        if let Some(err) = proto::json::Error::parse_rest(&res) {
2871            match err.typ.as_str() {
2872                "IdempotentParameterMismatchException" => {
2873                    return RusotoError::Service(
2874                        CreateRobotApplicationError::IdempotentParameterMismatch(err.msg),
2875                    )
2876                }
2877                "InternalServerException" => {
2878                    return RusotoError::Service(CreateRobotApplicationError::InternalServer(
2879                        err.msg,
2880                    ))
2881                }
2882                "InvalidParameterException" => {
2883                    return RusotoError::Service(CreateRobotApplicationError::InvalidParameter(
2884                        err.msg,
2885                    ))
2886                }
2887                "LimitExceededException" => {
2888                    return RusotoError::Service(CreateRobotApplicationError::LimitExceeded(
2889                        err.msg,
2890                    ))
2891                }
2892                "ResourceAlreadyExistsException" => {
2893                    return RusotoError::Service(
2894                        CreateRobotApplicationError::ResourceAlreadyExists(err.msg),
2895                    )
2896                }
2897                "ThrottlingException" => {
2898                    return RusotoError::Service(CreateRobotApplicationError::Throttling(err.msg))
2899                }
2900                "ValidationException" => return RusotoError::Validation(err.msg),
2901                _ => {}
2902            }
2903        }
2904        RusotoError::Unknown(res)
2905    }
2906}
2907impl fmt::Display for CreateRobotApplicationError {
2908    #[allow(unused_variables)]
2909    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2910        match *self {
2911            CreateRobotApplicationError::IdempotentParameterMismatch(ref cause) => {
2912                write!(f, "{}", cause)
2913            }
2914            CreateRobotApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
2915            CreateRobotApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2916            CreateRobotApplicationError::LimitExceeded(ref cause) => write!(f, "{}", cause),
2917            CreateRobotApplicationError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
2918            CreateRobotApplicationError::Throttling(ref cause) => write!(f, "{}", cause),
2919        }
2920    }
2921}
2922impl Error for CreateRobotApplicationError {}
2923/// Errors returned by CreateRobotApplicationVersion
2924#[derive(Debug, PartialEq)]
2925pub enum CreateRobotApplicationVersionError {
2926    /// <p>The request uses the same client token as a previous, but non-identical request. Do not reuse a client token with different requests, unless the requests are identical. </p>
2927    IdempotentParameterMismatch(String),
2928    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
2929    InternalServer(String),
2930    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
2931    InvalidParameter(String),
2932    /// <p>The requested resource exceeds the maximum number allowed, or the number of concurrent stream requests exceeds the maximum number allowed. </p>
2933    LimitExceeded(String),
2934    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
2935    Throttling(String),
2936}
2937
2938impl CreateRobotApplicationVersionError {
2939    pub fn from_response(
2940        res: BufferedHttpResponse,
2941    ) -> RusotoError<CreateRobotApplicationVersionError> {
2942        if let Some(err) = proto::json::Error::parse_rest(&res) {
2943            match err.typ.as_str() {
2944                "IdempotentParameterMismatchException" => {
2945                    return RusotoError::Service(
2946                        CreateRobotApplicationVersionError::IdempotentParameterMismatch(err.msg),
2947                    )
2948                }
2949                "InternalServerException" => {
2950                    return RusotoError::Service(
2951                        CreateRobotApplicationVersionError::InternalServer(err.msg),
2952                    )
2953                }
2954                "InvalidParameterException" => {
2955                    return RusotoError::Service(
2956                        CreateRobotApplicationVersionError::InvalidParameter(err.msg),
2957                    )
2958                }
2959                "LimitExceededException" => {
2960                    return RusotoError::Service(CreateRobotApplicationVersionError::LimitExceeded(
2961                        err.msg,
2962                    ))
2963                }
2964                "ThrottlingException" => {
2965                    return RusotoError::Service(CreateRobotApplicationVersionError::Throttling(
2966                        err.msg,
2967                    ))
2968                }
2969                "ValidationException" => return RusotoError::Validation(err.msg),
2970                _ => {}
2971            }
2972        }
2973        RusotoError::Unknown(res)
2974    }
2975}
2976impl fmt::Display for CreateRobotApplicationVersionError {
2977    #[allow(unused_variables)]
2978    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2979        match *self {
2980            CreateRobotApplicationVersionError::IdempotentParameterMismatch(ref cause) => {
2981                write!(f, "{}", cause)
2982            }
2983            CreateRobotApplicationVersionError::InternalServer(ref cause) => write!(f, "{}", cause),
2984            CreateRobotApplicationVersionError::InvalidParameter(ref cause) => {
2985                write!(f, "{}", cause)
2986            }
2987            CreateRobotApplicationVersionError::LimitExceeded(ref cause) => write!(f, "{}", cause),
2988            CreateRobotApplicationVersionError::Throttling(ref cause) => write!(f, "{}", cause),
2989        }
2990    }
2991}
2992impl Error for CreateRobotApplicationVersionError {}
2993/// Errors returned by CreateSimulationApplication
2994#[derive(Debug, PartialEq)]
2995pub enum CreateSimulationApplicationError {
2996    /// <p>The request uses the same client token as a previous, but non-identical request. Do not reuse a client token with different requests, unless the requests are identical. </p>
2997    IdempotentParameterMismatch(String),
2998    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
2999    InternalServer(String),
3000    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3001    InvalidParameter(String),
3002    /// <p>The requested resource exceeds the maximum number allowed, or the number of concurrent stream requests exceeds the maximum number allowed. </p>
3003    LimitExceeded(String),
3004    /// <p>The specified resource already exists.</p>
3005    ResourceAlreadyExists(String),
3006    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3007    Throttling(String),
3008}
3009
3010impl CreateSimulationApplicationError {
3011    pub fn from_response(
3012        res: BufferedHttpResponse,
3013    ) -> RusotoError<CreateSimulationApplicationError> {
3014        if let Some(err) = proto::json::Error::parse_rest(&res) {
3015            match err.typ.as_str() {
3016                "IdempotentParameterMismatchException" => {
3017                    return RusotoError::Service(
3018                        CreateSimulationApplicationError::IdempotentParameterMismatch(err.msg),
3019                    )
3020                }
3021                "InternalServerException" => {
3022                    return RusotoError::Service(CreateSimulationApplicationError::InternalServer(
3023                        err.msg,
3024                    ))
3025                }
3026                "InvalidParameterException" => {
3027                    return RusotoError::Service(
3028                        CreateSimulationApplicationError::InvalidParameter(err.msg),
3029                    )
3030                }
3031                "LimitExceededException" => {
3032                    return RusotoError::Service(CreateSimulationApplicationError::LimitExceeded(
3033                        err.msg,
3034                    ))
3035                }
3036                "ResourceAlreadyExistsException" => {
3037                    return RusotoError::Service(
3038                        CreateSimulationApplicationError::ResourceAlreadyExists(err.msg),
3039                    )
3040                }
3041                "ThrottlingException" => {
3042                    return RusotoError::Service(CreateSimulationApplicationError::Throttling(
3043                        err.msg,
3044                    ))
3045                }
3046                "ValidationException" => return RusotoError::Validation(err.msg),
3047                _ => {}
3048            }
3049        }
3050        RusotoError::Unknown(res)
3051    }
3052}
3053impl fmt::Display for CreateSimulationApplicationError {
3054    #[allow(unused_variables)]
3055    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3056        match *self {
3057            CreateSimulationApplicationError::IdempotentParameterMismatch(ref cause) => {
3058                write!(f, "{}", cause)
3059            }
3060            CreateSimulationApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
3061            CreateSimulationApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3062            CreateSimulationApplicationError::LimitExceeded(ref cause) => write!(f, "{}", cause),
3063            CreateSimulationApplicationError::ResourceAlreadyExists(ref cause) => {
3064                write!(f, "{}", cause)
3065            }
3066            CreateSimulationApplicationError::Throttling(ref cause) => write!(f, "{}", cause),
3067        }
3068    }
3069}
3070impl Error for CreateSimulationApplicationError {}
3071/// Errors returned by CreateSimulationApplicationVersion
3072#[derive(Debug, PartialEq)]
3073pub enum CreateSimulationApplicationVersionError {
3074    /// <p>The request uses the same client token as a previous, but non-identical request. Do not reuse a client token with different requests, unless the requests are identical. </p>
3075    IdempotentParameterMismatch(String),
3076    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3077    InternalServer(String),
3078    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3079    InvalidParameter(String),
3080    /// <p>The requested resource exceeds the maximum number allowed, or the number of concurrent stream requests exceeds the maximum number allowed. </p>
3081    LimitExceeded(String),
3082    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3083    Throttling(String),
3084}
3085
3086impl CreateSimulationApplicationVersionError {
3087    pub fn from_response(
3088        res: BufferedHttpResponse,
3089    ) -> RusotoError<CreateSimulationApplicationVersionError> {
3090        if let Some(err) = proto::json::Error::parse_rest(&res) {
3091            match err.typ.as_str() {
3092                "IdempotentParameterMismatchException" => {
3093                    return RusotoError::Service(
3094                        CreateSimulationApplicationVersionError::IdempotentParameterMismatch(
3095                            err.msg,
3096                        ),
3097                    )
3098                }
3099                "InternalServerException" => {
3100                    return RusotoError::Service(
3101                        CreateSimulationApplicationVersionError::InternalServer(err.msg),
3102                    )
3103                }
3104                "InvalidParameterException" => {
3105                    return RusotoError::Service(
3106                        CreateSimulationApplicationVersionError::InvalidParameter(err.msg),
3107                    )
3108                }
3109                "LimitExceededException" => {
3110                    return RusotoError::Service(
3111                        CreateSimulationApplicationVersionError::LimitExceeded(err.msg),
3112                    )
3113                }
3114                "ThrottlingException" => {
3115                    return RusotoError::Service(
3116                        CreateSimulationApplicationVersionError::Throttling(err.msg),
3117                    )
3118                }
3119                "ValidationException" => return RusotoError::Validation(err.msg),
3120                _ => {}
3121            }
3122        }
3123        RusotoError::Unknown(res)
3124    }
3125}
3126impl fmt::Display for CreateSimulationApplicationVersionError {
3127    #[allow(unused_variables)]
3128    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3129        match *self {
3130            CreateSimulationApplicationVersionError::IdempotentParameterMismatch(ref cause) => {
3131                write!(f, "{}", cause)
3132            }
3133            CreateSimulationApplicationVersionError::InternalServer(ref cause) => {
3134                write!(f, "{}", cause)
3135            }
3136            CreateSimulationApplicationVersionError::InvalidParameter(ref cause) => {
3137                write!(f, "{}", cause)
3138            }
3139            CreateSimulationApplicationVersionError::LimitExceeded(ref cause) => {
3140                write!(f, "{}", cause)
3141            }
3142            CreateSimulationApplicationVersionError::Throttling(ref cause) => {
3143                write!(f, "{}", cause)
3144            }
3145        }
3146    }
3147}
3148impl Error for CreateSimulationApplicationVersionError {}
3149/// Errors returned by CreateSimulationJob
3150#[derive(Debug, PartialEq)]
3151pub enum CreateSimulationJobError {
3152    /// <p>The request uses the same client token as a previous, but non-identical request. Do not reuse a client token with different requests, unless the requests are identical. </p>
3153    IdempotentParameterMismatch(String),
3154    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3155    InternalServer(String),
3156    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3157    InvalidParameter(String),
3158    /// <p>The requested resource exceeds the maximum number allowed, or the number of concurrent stream requests exceeds the maximum number allowed. </p>
3159    LimitExceeded(String),
3160    /// <p>The specified resource does not exist.</p>
3161    ResourceNotFound(String),
3162    /// <p>The request has failed due to a temporary failure of the server.</p>
3163    ServiceUnavailable(String),
3164    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3165    Throttling(String),
3166}
3167
3168impl CreateSimulationJobError {
3169    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSimulationJobError> {
3170        if let Some(err) = proto::json::Error::parse_rest(&res) {
3171            match err.typ.as_str() {
3172                "IdempotentParameterMismatchException" => {
3173                    return RusotoError::Service(
3174                        CreateSimulationJobError::IdempotentParameterMismatch(err.msg),
3175                    )
3176                }
3177                "InternalServerException" => {
3178                    return RusotoError::Service(CreateSimulationJobError::InternalServer(err.msg))
3179                }
3180                "InvalidParameterException" => {
3181                    return RusotoError::Service(CreateSimulationJobError::InvalidParameter(
3182                        err.msg,
3183                    ))
3184                }
3185                "LimitExceededException" => {
3186                    return RusotoError::Service(CreateSimulationJobError::LimitExceeded(err.msg))
3187                }
3188                "ResourceNotFoundException" => {
3189                    return RusotoError::Service(CreateSimulationJobError::ResourceNotFound(
3190                        err.msg,
3191                    ))
3192                }
3193                "ServiceUnavailableException" => {
3194                    return RusotoError::Service(CreateSimulationJobError::ServiceUnavailable(
3195                        err.msg,
3196                    ))
3197                }
3198                "ThrottlingException" => {
3199                    return RusotoError::Service(CreateSimulationJobError::Throttling(err.msg))
3200                }
3201                "ValidationException" => return RusotoError::Validation(err.msg),
3202                _ => {}
3203            }
3204        }
3205        RusotoError::Unknown(res)
3206    }
3207}
3208impl fmt::Display for CreateSimulationJobError {
3209    #[allow(unused_variables)]
3210    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3211        match *self {
3212            CreateSimulationJobError::IdempotentParameterMismatch(ref cause) => {
3213                write!(f, "{}", cause)
3214            }
3215            CreateSimulationJobError::InternalServer(ref cause) => write!(f, "{}", cause),
3216            CreateSimulationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3217            CreateSimulationJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
3218            CreateSimulationJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
3219            CreateSimulationJobError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
3220            CreateSimulationJobError::Throttling(ref cause) => write!(f, "{}", cause),
3221        }
3222    }
3223}
3224impl Error for CreateSimulationJobError {}
3225/// Errors returned by DeleteFleet
3226#[derive(Debug, PartialEq)]
3227pub enum DeleteFleetError {
3228    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3229    InternalServer(String),
3230    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3231    InvalidParameter(String),
3232    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3233    Throttling(String),
3234}
3235
3236impl DeleteFleetError {
3237    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFleetError> {
3238        if let Some(err) = proto::json::Error::parse_rest(&res) {
3239            match err.typ.as_str() {
3240                "InternalServerException" => {
3241                    return RusotoError::Service(DeleteFleetError::InternalServer(err.msg))
3242                }
3243                "InvalidParameterException" => {
3244                    return RusotoError::Service(DeleteFleetError::InvalidParameter(err.msg))
3245                }
3246                "ThrottlingException" => {
3247                    return RusotoError::Service(DeleteFleetError::Throttling(err.msg))
3248                }
3249                "ValidationException" => return RusotoError::Validation(err.msg),
3250                _ => {}
3251            }
3252        }
3253        RusotoError::Unknown(res)
3254    }
3255}
3256impl fmt::Display for DeleteFleetError {
3257    #[allow(unused_variables)]
3258    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3259        match *self {
3260            DeleteFleetError::InternalServer(ref cause) => write!(f, "{}", cause),
3261            DeleteFleetError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3262            DeleteFleetError::Throttling(ref cause) => write!(f, "{}", cause),
3263        }
3264    }
3265}
3266impl Error for DeleteFleetError {}
3267/// Errors returned by DeleteRobot
3268#[derive(Debug, PartialEq)]
3269pub enum DeleteRobotError {
3270    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3271    InternalServer(String),
3272    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3273    InvalidParameter(String),
3274    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3275    Throttling(String),
3276}
3277
3278impl DeleteRobotError {
3279    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteRobotError> {
3280        if let Some(err) = proto::json::Error::parse_rest(&res) {
3281            match err.typ.as_str() {
3282                "InternalServerException" => {
3283                    return RusotoError::Service(DeleteRobotError::InternalServer(err.msg))
3284                }
3285                "InvalidParameterException" => {
3286                    return RusotoError::Service(DeleteRobotError::InvalidParameter(err.msg))
3287                }
3288                "ThrottlingException" => {
3289                    return RusotoError::Service(DeleteRobotError::Throttling(err.msg))
3290                }
3291                "ValidationException" => return RusotoError::Validation(err.msg),
3292                _ => {}
3293            }
3294        }
3295        RusotoError::Unknown(res)
3296    }
3297}
3298impl fmt::Display for DeleteRobotError {
3299    #[allow(unused_variables)]
3300    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3301        match *self {
3302            DeleteRobotError::InternalServer(ref cause) => write!(f, "{}", cause),
3303            DeleteRobotError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3304            DeleteRobotError::Throttling(ref cause) => write!(f, "{}", cause),
3305        }
3306    }
3307}
3308impl Error for DeleteRobotError {}
3309/// Errors returned by DeleteRobotApplication
3310#[derive(Debug, PartialEq)]
3311pub enum DeleteRobotApplicationError {
3312    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3313    InternalServer(String),
3314    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3315    InvalidParameter(String),
3316    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3317    Throttling(String),
3318}
3319
3320impl DeleteRobotApplicationError {
3321    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteRobotApplicationError> {
3322        if let Some(err) = proto::json::Error::parse_rest(&res) {
3323            match err.typ.as_str() {
3324                "InternalServerException" => {
3325                    return RusotoError::Service(DeleteRobotApplicationError::InternalServer(
3326                        err.msg,
3327                    ))
3328                }
3329                "InvalidParameterException" => {
3330                    return RusotoError::Service(DeleteRobotApplicationError::InvalidParameter(
3331                        err.msg,
3332                    ))
3333                }
3334                "ThrottlingException" => {
3335                    return RusotoError::Service(DeleteRobotApplicationError::Throttling(err.msg))
3336                }
3337                "ValidationException" => return RusotoError::Validation(err.msg),
3338                _ => {}
3339            }
3340        }
3341        RusotoError::Unknown(res)
3342    }
3343}
3344impl fmt::Display for DeleteRobotApplicationError {
3345    #[allow(unused_variables)]
3346    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3347        match *self {
3348            DeleteRobotApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
3349            DeleteRobotApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3350            DeleteRobotApplicationError::Throttling(ref cause) => write!(f, "{}", cause),
3351        }
3352    }
3353}
3354impl Error for DeleteRobotApplicationError {}
3355/// Errors returned by DeleteSimulationApplication
3356#[derive(Debug, PartialEq)]
3357pub enum DeleteSimulationApplicationError {
3358    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3359    InternalServer(String),
3360    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3361    InvalidParameter(String),
3362    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3363    Throttling(String),
3364}
3365
3366impl DeleteSimulationApplicationError {
3367    pub fn from_response(
3368        res: BufferedHttpResponse,
3369    ) -> RusotoError<DeleteSimulationApplicationError> {
3370        if let Some(err) = proto::json::Error::parse_rest(&res) {
3371            match err.typ.as_str() {
3372                "InternalServerException" => {
3373                    return RusotoError::Service(DeleteSimulationApplicationError::InternalServer(
3374                        err.msg,
3375                    ))
3376                }
3377                "InvalidParameterException" => {
3378                    return RusotoError::Service(
3379                        DeleteSimulationApplicationError::InvalidParameter(err.msg),
3380                    )
3381                }
3382                "ThrottlingException" => {
3383                    return RusotoError::Service(DeleteSimulationApplicationError::Throttling(
3384                        err.msg,
3385                    ))
3386                }
3387                "ValidationException" => return RusotoError::Validation(err.msg),
3388                _ => {}
3389            }
3390        }
3391        RusotoError::Unknown(res)
3392    }
3393}
3394impl fmt::Display for DeleteSimulationApplicationError {
3395    #[allow(unused_variables)]
3396    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3397        match *self {
3398            DeleteSimulationApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
3399            DeleteSimulationApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3400            DeleteSimulationApplicationError::Throttling(ref cause) => write!(f, "{}", cause),
3401        }
3402    }
3403}
3404impl Error for DeleteSimulationApplicationError {}
3405/// Errors returned by DeregisterRobot
3406#[derive(Debug, PartialEq)]
3407pub enum DeregisterRobotError {
3408    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3409    InternalServer(String),
3410    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3411    InvalidParameter(String),
3412    /// <p>The specified resource does not exist.</p>
3413    ResourceNotFound(String),
3414    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3415    Throttling(String),
3416}
3417
3418impl DeregisterRobotError {
3419    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeregisterRobotError> {
3420        if let Some(err) = proto::json::Error::parse_rest(&res) {
3421            match err.typ.as_str() {
3422                "InternalServerException" => {
3423                    return RusotoError::Service(DeregisterRobotError::InternalServer(err.msg))
3424                }
3425                "InvalidParameterException" => {
3426                    return RusotoError::Service(DeregisterRobotError::InvalidParameter(err.msg))
3427                }
3428                "ResourceNotFoundException" => {
3429                    return RusotoError::Service(DeregisterRobotError::ResourceNotFound(err.msg))
3430                }
3431                "ThrottlingException" => {
3432                    return RusotoError::Service(DeregisterRobotError::Throttling(err.msg))
3433                }
3434                "ValidationException" => return RusotoError::Validation(err.msg),
3435                _ => {}
3436            }
3437        }
3438        RusotoError::Unknown(res)
3439    }
3440}
3441impl fmt::Display for DeregisterRobotError {
3442    #[allow(unused_variables)]
3443    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3444        match *self {
3445            DeregisterRobotError::InternalServer(ref cause) => write!(f, "{}", cause),
3446            DeregisterRobotError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3447            DeregisterRobotError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
3448            DeregisterRobotError::Throttling(ref cause) => write!(f, "{}", cause),
3449        }
3450    }
3451}
3452impl Error for DeregisterRobotError {}
3453/// Errors returned by DescribeDeploymentJob
3454#[derive(Debug, PartialEq)]
3455pub enum DescribeDeploymentJobError {
3456    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3457    InternalServer(String),
3458    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3459    InvalidParameter(String),
3460    /// <p>The specified resource does not exist.</p>
3461    ResourceNotFound(String),
3462    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3463    Throttling(String),
3464}
3465
3466impl DescribeDeploymentJobError {
3467    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDeploymentJobError> {
3468        if let Some(err) = proto::json::Error::parse_rest(&res) {
3469            match err.typ.as_str() {
3470                "InternalServerException" => {
3471                    return RusotoError::Service(DescribeDeploymentJobError::InternalServer(
3472                        err.msg,
3473                    ))
3474                }
3475                "InvalidParameterException" => {
3476                    return RusotoError::Service(DescribeDeploymentJobError::InvalidParameter(
3477                        err.msg,
3478                    ))
3479                }
3480                "ResourceNotFoundException" => {
3481                    return RusotoError::Service(DescribeDeploymentJobError::ResourceNotFound(
3482                        err.msg,
3483                    ))
3484                }
3485                "ThrottlingException" => {
3486                    return RusotoError::Service(DescribeDeploymentJobError::Throttling(err.msg))
3487                }
3488                "ValidationException" => return RusotoError::Validation(err.msg),
3489                _ => {}
3490            }
3491        }
3492        RusotoError::Unknown(res)
3493    }
3494}
3495impl fmt::Display for DescribeDeploymentJobError {
3496    #[allow(unused_variables)]
3497    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3498        match *self {
3499            DescribeDeploymentJobError::InternalServer(ref cause) => write!(f, "{}", cause),
3500            DescribeDeploymentJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3501            DescribeDeploymentJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
3502            DescribeDeploymentJobError::Throttling(ref cause) => write!(f, "{}", cause),
3503        }
3504    }
3505}
3506impl Error for DescribeDeploymentJobError {}
3507/// Errors returned by DescribeFleet
3508#[derive(Debug, PartialEq)]
3509pub enum DescribeFleetError {
3510    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3511    InternalServer(String),
3512    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3513    InvalidParameter(String),
3514    /// <p>The specified resource does not exist.</p>
3515    ResourceNotFound(String),
3516    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3517    Throttling(String),
3518}
3519
3520impl DescribeFleetError {
3521    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeFleetError> {
3522        if let Some(err) = proto::json::Error::parse_rest(&res) {
3523            match err.typ.as_str() {
3524                "InternalServerException" => {
3525                    return RusotoError::Service(DescribeFleetError::InternalServer(err.msg))
3526                }
3527                "InvalidParameterException" => {
3528                    return RusotoError::Service(DescribeFleetError::InvalidParameter(err.msg))
3529                }
3530                "ResourceNotFoundException" => {
3531                    return RusotoError::Service(DescribeFleetError::ResourceNotFound(err.msg))
3532                }
3533                "ThrottlingException" => {
3534                    return RusotoError::Service(DescribeFleetError::Throttling(err.msg))
3535                }
3536                "ValidationException" => return RusotoError::Validation(err.msg),
3537                _ => {}
3538            }
3539        }
3540        RusotoError::Unknown(res)
3541    }
3542}
3543impl fmt::Display for DescribeFleetError {
3544    #[allow(unused_variables)]
3545    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3546        match *self {
3547            DescribeFleetError::InternalServer(ref cause) => write!(f, "{}", cause),
3548            DescribeFleetError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3549            DescribeFleetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
3550            DescribeFleetError::Throttling(ref cause) => write!(f, "{}", cause),
3551        }
3552    }
3553}
3554impl Error for DescribeFleetError {}
3555/// Errors returned by DescribeRobot
3556#[derive(Debug, PartialEq)]
3557pub enum DescribeRobotError {
3558    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3559    InternalServer(String),
3560    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3561    InvalidParameter(String),
3562    /// <p>The specified resource does not exist.</p>
3563    ResourceNotFound(String),
3564    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3565    Throttling(String),
3566}
3567
3568impl DescribeRobotError {
3569    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeRobotError> {
3570        if let Some(err) = proto::json::Error::parse_rest(&res) {
3571            match err.typ.as_str() {
3572                "InternalServerException" => {
3573                    return RusotoError::Service(DescribeRobotError::InternalServer(err.msg))
3574                }
3575                "InvalidParameterException" => {
3576                    return RusotoError::Service(DescribeRobotError::InvalidParameter(err.msg))
3577                }
3578                "ResourceNotFoundException" => {
3579                    return RusotoError::Service(DescribeRobotError::ResourceNotFound(err.msg))
3580                }
3581                "ThrottlingException" => {
3582                    return RusotoError::Service(DescribeRobotError::Throttling(err.msg))
3583                }
3584                "ValidationException" => return RusotoError::Validation(err.msg),
3585                _ => {}
3586            }
3587        }
3588        RusotoError::Unknown(res)
3589    }
3590}
3591impl fmt::Display for DescribeRobotError {
3592    #[allow(unused_variables)]
3593    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3594        match *self {
3595            DescribeRobotError::InternalServer(ref cause) => write!(f, "{}", cause),
3596            DescribeRobotError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3597            DescribeRobotError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
3598            DescribeRobotError::Throttling(ref cause) => write!(f, "{}", cause),
3599        }
3600    }
3601}
3602impl Error for DescribeRobotError {}
3603/// Errors returned by DescribeRobotApplication
3604#[derive(Debug, PartialEq)]
3605pub enum DescribeRobotApplicationError {
3606    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3607    InternalServer(String),
3608    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3609    InvalidParameter(String),
3610    /// <p>The specified resource does not exist.</p>
3611    ResourceNotFound(String),
3612    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3613    Throttling(String),
3614}
3615
3616impl DescribeRobotApplicationError {
3617    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeRobotApplicationError> {
3618        if let Some(err) = proto::json::Error::parse_rest(&res) {
3619            match err.typ.as_str() {
3620                "InternalServerException" => {
3621                    return RusotoError::Service(DescribeRobotApplicationError::InternalServer(
3622                        err.msg,
3623                    ))
3624                }
3625                "InvalidParameterException" => {
3626                    return RusotoError::Service(DescribeRobotApplicationError::InvalidParameter(
3627                        err.msg,
3628                    ))
3629                }
3630                "ResourceNotFoundException" => {
3631                    return RusotoError::Service(DescribeRobotApplicationError::ResourceNotFound(
3632                        err.msg,
3633                    ))
3634                }
3635                "ThrottlingException" => {
3636                    return RusotoError::Service(DescribeRobotApplicationError::Throttling(err.msg))
3637                }
3638                "ValidationException" => return RusotoError::Validation(err.msg),
3639                _ => {}
3640            }
3641        }
3642        RusotoError::Unknown(res)
3643    }
3644}
3645impl fmt::Display for DescribeRobotApplicationError {
3646    #[allow(unused_variables)]
3647    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3648        match *self {
3649            DescribeRobotApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
3650            DescribeRobotApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3651            DescribeRobotApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
3652            DescribeRobotApplicationError::Throttling(ref cause) => write!(f, "{}", cause),
3653        }
3654    }
3655}
3656impl Error for DescribeRobotApplicationError {}
3657/// Errors returned by DescribeSimulationApplication
3658#[derive(Debug, PartialEq)]
3659pub enum DescribeSimulationApplicationError {
3660    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3661    InternalServer(String),
3662    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3663    InvalidParameter(String),
3664    /// <p>The specified resource does not exist.</p>
3665    ResourceNotFound(String),
3666    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3667    Throttling(String),
3668}
3669
3670impl DescribeSimulationApplicationError {
3671    pub fn from_response(
3672        res: BufferedHttpResponse,
3673    ) -> RusotoError<DescribeSimulationApplicationError> {
3674        if let Some(err) = proto::json::Error::parse_rest(&res) {
3675            match err.typ.as_str() {
3676                "InternalServerException" => {
3677                    return RusotoError::Service(
3678                        DescribeSimulationApplicationError::InternalServer(err.msg),
3679                    )
3680                }
3681                "InvalidParameterException" => {
3682                    return RusotoError::Service(
3683                        DescribeSimulationApplicationError::InvalidParameter(err.msg),
3684                    )
3685                }
3686                "ResourceNotFoundException" => {
3687                    return RusotoError::Service(
3688                        DescribeSimulationApplicationError::ResourceNotFound(err.msg),
3689                    )
3690                }
3691                "ThrottlingException" => {
3692                    return RusotoError::Service(DescribeSimulationApplicationError::Throttling(
3693                        err.msg,
3694                    ))
3695                }
3696                "ValidationException" => return RusotoError::Validation(err.msg),
3697                _ => {}
3698            }
3699        }
3700        RusotoError::Unknown(res)
3701    }
3702}
3703impl fmt::Display for DescribeSimulationApplicationError {
3704    #[allow(unused_variables)]
3705    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3706        match *self {
3707            DescribeSimulationApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
3708            DescribeSimulationApplicationError::InvalidParameter(ref cause) => {
3709                write!(f, "{}", cause)
3710            }
3711            DescribeSimulationApplicationError::ResourceNotFound(ref cause) => {
3712                write!(f, "{}", cause)
3713            }
3714            DescribeSimulationApplicationError::Throttling(ref cause) => write!(f, "{}", cause),
3715        }
3716    }
3717}
3718impl Error for DescribeSimulationApplicationError {}
3719/// Errors returned by DescribeSimulationJob
3720#[derive(Debug, PartialEq)]
3721pub enum DescribeSimulationJobError {
3722    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3723    InternalServer(String),
3724    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3725    InvalidParameter(String),
3726    /// <p>The specified resource does not exist.</p>
3727    ResourceNotFound(String),
3728    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3729    Throttling(String),
3730}
3731
3732impl DescribeSimulationJobError {
3733    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSimulationJobError> {
3734        if let Some(err) = proto::json::Error::parse_rest(&res) {
3735            match err.typ.as_str() {
3736                "InternalServerException" => {
3737                    return RusotoError::Service(DescribeSimulationJobError::InternalServer(
3738                        err.msg,
3739                    ))
3740                }
3741                "InvalidParameterException" => {
3742                    return RusotoError::Service(DescribeSimulationJobError::InvalidParameter(
3743                        err.msg,
3744                    ))
3745                }
3746                "ResourceNotFoundException" => {
3747                    return RusotoError::Service(DescribeSimulationJobError::ResourceNotFound(
3748                        err.msg,
3749                    ))
3750                }
3751                "ThrottlingException" => {
3752                    return RusotoError::Service(DescribeSimulationJobError::Throttling(err.msg))
3753                }
3754                "ValidationException" => return RusotoError::Validation(err.msg),
3755                _ => {}
3756            }
3757        }
3758        RusotoError::Unknown(res)
3759    }
3760}
3761impl fmt::Display for DescribeSimulationJobError {
3762    #[allow(unused_variables)]
3763    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3764        match *self {
3765            DescribeSimulationJobError::InternalServer(ref cause) => write!(f, "{}", cause),
3766            DescribeSimulationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3767            DescribeSimulationJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
3768            DescribeSimulationJobError::Throttling(ref cause) => write!(f, "{}", cause),
3769        }
3770    }
3771}
3772impl Error for DescribeSimulationJobError {}
3773/// Errors returned by DescribeSimulationJobBatch
3774#[derive(Debug, PartialEq)]
3775pub enum DescribeSimulationJobBatchError {
3776    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3777    InternalServer(String),
3778    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3779    InvalidParameter(String),
3780    /// <p>The specified resource does not exist.</p>
3781    ResourceNotFound(String),
3782}
3783
3784impl DescribeSimulationJobBatchError {
3785    pub fn from_response(
3786        res: BufferedHttpResponse,
3787    ) -> RusotoError<DescribeSimulationJobBatchError> {
3788        if let Some(err) = proto::json::Error::parse_rest(&res) {
3789            match err.typ.as_str() {
3790                "InternalServerException" => {
3791                    return RusotoError::Service(DescribeSimulationJobBatchError::InternalServer(
3792                        err.msg,
3793                    ))
3794                }
3795                "InvalidParameterException" => {
3796                    return RusotoError::Service(DescribeSimulationJobBatchError::InvalidParameter(
3797                        err.msg,
3798                    ))
3799                }
3800                "ResourceNotFoundException" => {
3801                    return RusotoError::Service(DescribeSimulationJobBatchError::ResourceNotFound(
3802                        err.msg,
3803                    ))
3804                }
3805                "ValidationException" => return RusotoError::Validation(err.msg),
3806                _ => {}
3807            }
3808        }
3809        RusotoError::Unknown(res)
3810    }
3811}
3812impl fmt::Display for DescribeSimulationJobBatchError {
3813    #[allow(unused_variables)]
3814    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3815        match *self {
3816            DescribeSimulationJobBatchError::InternalServer(ref cause) => write!(f, "{}", cause),
3817            DescribeSimulationJobBatchError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3818            DescribeSimulationJobBatchError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
3819        }
3820    }
3821}
3822impl Error for DescribeSimulationJobBatchError {}
3823/// Errors returned by ListDeploymentJobs
3824#[derive(Debug, PartialEq)]
3825pub enum ListDeploymentJobsError {
3826    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3827    InternalServer(String),
3828    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3829    InvalidParameter(String),
3830    /// <p>The specified resource does not exist.</p>
3831    ResourceNotFound(String),
3832    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3833    Throttling(String),
3834}
3835
3836impl ListDeploymentJobsError {
3837    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDeploymentJobsError> {
3838        if let Some(err) = proto::json::Error::parse_rest(&res) {
3839            match err.typ.as_str() {
3840                "InternalServerException" => {
3841                    return RusotoError::Service(ListDeploymentJobsError::InternalServer(err.msg))
3842                }
3843                "InvalidParameterException" => {
3844                    return RusotoError::Service(ListDeploymentJobsError::InvalidParameter(err.msg))
3845                }
3846                "ResourceNotFoundException" => {
3847                    return RusotoError::Service(ListDeploymentJobsError::ResourceNotFound(err.msg))
3848                }
3849                "ThrottlingException" => {
3850                    return RusotoError::Service(ListDeploymentJobsError::Throttling(err.msg))
3851                }
3852                "ValidationException" => return RusotoError::Validation(err.msg),
3853                _ => {}
3854            }
3855        }
3856        RusotoError::Unknown(res)
3857    }
3858}
3859impl fmt::Display for ListDeploymentJobsError {
3860    #[allow(unused_variables)]
3861    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3862        match *self {
3863            ListDeploymentJobsError::InternalServer(ref cause) => write!(f, "{}", cause),
3864            ListDeploymentJobsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3865            ListDeploymentJobsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
3866            ListDeploymentJobsError::Throttling(ref cause) => write!(f, "{}", cause),
3867        }
3868    }
3869}
3870impl Error for ListDeploymentJobsError {}
3871/// Errors returned by ListFleets
3872#[derive(Debug, PartialEq)]
3873pub enum ListFleetsError {
3874    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3875    InternalServer(String),
3876    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3877    InvalidParameter(String),
3878    /// <p>The specified resource does not exist.</p>
3879    ResourceNotFound(String),
3880    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3881    Throttling(String),
3882}
3883
3884impl ListFleetsError {
3885    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListFleetsError> {
3886        if let Some(err) = proto::json::Error::parse_rest(&res) {
3887            match err.typ.as_str() {
3888                "InternalServerException" => {
3889                    return RusotoError::Service(ListFleetsError::InternalServer(err.msg))
3890                }
3891                "InvalidParameterException" => {
3892                    return RusotoError::Service(ListFleetsError::InvalidParameter(err.msg))
3893                }
3894                "ResourceNotFoundException" => {
3895                    return RusotoError::Service(ListFleetsError::ResourceNotFound(err.msg))
3896                }
3897                "ThrottlingException" => {
3898                    return RusotoError::Service(ListFleetsError::Throttling(err.msg))
3899                }
3900                "ValidationException" => return RusotoError::Validation(err.msg),
3901                _ => {}
3902            }
3903        }
3904        RusotoError::Unknown(res)
3905    }
3906}
3907impl fmt::Display for ListFleetsError {
3908    #[allow(unused_variables)]
3909    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3910        match *self {
3911            ListFleetsError::InternalServer(ref cause) => write!(f, "{}", cause),
3912            ListFleetsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3913            ListFleetsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
3914            ListFleetsError::Throttling(ref cause) => write!(f, "{}", cause),
3915        }
3916    }
3917}
3918impl Error for ListFleetsError {}
3919/// Errors returned by ListRobotApplications
3920#[derive(Debug, PartialEq)]
3921pub enum ListRobotApplicationsError {
3922    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3923    InternalServer(String),
3924    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3925    InvalidParameter(String),
3926    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3927    Throttling(String),
3928}
3929
3930impl ListRobotApplicationsError {
3931    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListRobotApplicationsError> {
3932        if let Some(err) = proto::json::Error::parse_rest(&res) {
3933            match err.typ.as_str() {
3934                "InternalServerException" => {
3935                    return RusotoError::Service(ListRobotApplicationsError::InternalServer(
3936                        err.msg,
3937                    ))
3938                }
3939                "InvalidParameterException" => {
3940                    return RusotoError::Service(ListRobotApplicationsError::InvalidParameter(
3941                        err.msg,
3942                    ))
3943                }
3944                "ThrottlingException" => {
3945                    return RusotoError::Service(ListRobotApplicationsError::Throttling(err.msg))
3946                }
3947                "ValidationException" => return RusotoError::Validation(err.msg),
3948                _ => {}
3949            }
3950        }
3951        RusotoError::Unknown(res)
3952    }
3953}
3954impl fmt::Display for ListRobotApplicationsError {
3955    #[allow(unused_variables)]
3956    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3957        match *self {
3958            ListRobotApplicationsError::InternalServer(ref cause) => write!(f, "{}", cause),
3959            ListRobotApplicationsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3960            ListRobotApplicationsError::Throttling(ref cause) => write!(f, "{}", cause),
3961        }
3962    }
3963}
3964impl Error for ListRobotApplicationsError {}
3965/// Errors returned by ListRobots
3966#[derive(Debug, PartialEq)]
3967pub enum ListRobotsError {
3968    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
3969    InternalServer(String),
3970    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
3971    InvalidParameter(String),
3972    /// <p>The specified resource does not exist.</p>
3973    ResourceNotFound(String),
3974    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
3975    Throttling(String),
3976}
3977
3978impl ListRobotsError {
3979    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListRobotsError> {
3980        if let Some(err) = proto::json::Error::parse_rest(&res) {
3981            match err.typ.as_str() {
3982                "InternalServerException" => {
3983                    return RusotoError::Service(ListRobotsError::InternalServer(err.msg))
3984                }
3985                "InvalidParameterException" => {
3986                    return RusotoError::Service(ListRobotsError::InvalidParameter(err.msg))
3987                }
3988                "ResourceNotFoundException" => {
3989                    return RusotoError::Service(ListRobotsError::ResourceNotFound(err.msg))
3990                }
3991                "ThrottlingException" => {
3992                    return RusotoError::Service(ListRobotsError::Throttling(err.msg))
3993                }
3994                "ValidationException" => return RusotoError::Validation(err.msg),
3995                _ => {}
3996            }
3997        }
3998        RusotoError::Unknown(res)
3999    }
4000}
4001impl fmt::Display for ListRobotsError {
4002    #[allow(unused_variables)]
4003    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4004        match *self {
4005            ListRobotsError::InternalServer(ref cause) => write!(f, "{}", cause),
4006            ListRobotsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
4007            ListRobotsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
4008            ListRobotsError::Throttling(ref cause) => write!(f, "{}", cause),
4009        }
4010    }
4011}
4012impl Error for ListRobotsError {}
4013/// Errors returned by ListSimulationApplications
4014#[derive(Debug, PartialEq)]
4015pub enum ListSimulationApplicationsError {
4016    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
4017    InternalServer(String),
4018    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
4019    InvalidParameter(String),
4020    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
4021    Throttling(String),
4022}
4023
4024impl ListSimulationApplicationsError {
4025    pub fn from_response(
4026        res: BufferedHttpResponse,
4027    ) -> RusotoError<ListSimulationApplicationsError> {
4028        if let Some(err) = proto::json::Error::parse_rest(&res) {
4029            match err.typ.as_str() {
4030                "InternalServerException" => {
4031                    return RusotoError::Service(ListSimulationApplicationsError::InternalServer(
4032                        err.msg,
4033                    ))
4034                }
4035                "InvalidParameterException" => {
4036                    return RusotoError::Service(ListSimulationApplicationsError::InvalidParameter(
4037                        err.msg,
4038                    ))
4039                }
4040                "ThrottlingException" => {
4041                    return RusotoError::Service(ListSimulationApplicationsError::Throttling(
4042                        err.msg,
4043                    ))
4044                }
4045                "ValidationException" => return RusotoError::Validation(err.msg),
4046                _ => {}
4047            }
4048        }
4049        RusotoError::Unknown(res)
4050    }
4051}
4052impl fmt::Display for ListSimulationApplicationsError {
4053    #[allow(unused_variables)]
4054    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4055        match *self {
4056            ListSimulationApplicationsError::InternalServer(ref cause) => write!(f, "{}", cause),
4057            ListSimulationApplicationsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
4058            ListSimulationApplicationsError::Throttling(ref cause) => write!(f, "{}", cause),
4059        }
4060    }
4061}
4062impl Error for ListSimulationApplicationsError {}
4063/// Errors returned by ListSimulationJobBatches
4064#[derive(Debug, PartialEq)]
4065pub enum ListSimulationJobBatchesError {
4066    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
4067    InternalServer(String),
4068    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
4069    InvalidParameter(String),
4070}
4071
4072impl ListSimulationJobBatchesError {
4073    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSimulationJobBatchesError> {
4074        if let Some(err) = proto::json::Error::parse_rest(&res) {
4075            match err.typ.as_str() {
4076                "InternalServerException" => {
4077                    return RusotoError::Service(ListSimulationJobBatchesError::InternalServer(
4078                        err.msg,
4079                    ))
4080                }
4081                "InvalidParameterException" => {
4082                    return RusotoError::Service(ListSimulationJobBatchesError::InvalidParameter(
4083                        err.msg,
4084                    ))
4085                }
4086                "ValidationException" => return RusotoError::Validation(err.msg),
4087                _ => {}
4088            }
4089        }
4090        RusotoError::Unknown(res)
4091    }
4092}
4093impl fmt::Display for ListSimulationJobBatchesError {
4094    #[allow(unused_variables)]
4095    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4096        match *self {
4097            ListSimulationJobBatchesError::InternalServer(ref cause) => write!(f, "{}", cause),
4098            ListSimulationJobBatchesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
4099        }
4100    }
4101}
4102impl Error for ListSimulationJobBatchesError {}
4103/// Errors returned by ListSimulationJobs
4104#[derive(Debug, PartialEq)]
4105pub enum ListSimulationJobsError {
4106    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
4107    InternalServer(String),
4108    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
4109    InvalidParameter(String),
4110    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
4111    Throttling(String),
4112}
4113
4114impl ListSimulationJobsError {
4115    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSimulationJobsError> {
4116        if let Some(err) = proto::json::Error::parse_rest(&res) {
4117            match err.typ.as_str() {
4118                "InternalServerException" => {
4119                    return RusotoError::Service(ListSimulationJobsError::InternalServer(err.msg))
4120                }
4121                "InvalidParameterException" => {
4122                    return RusotoError::Service(ListSimulationJobsError::InvalidParameter(err.msg))
4123                }
4124                "ThrottlingException" => {
4125                    return RusotoError::Service(ListSimulationJobsError::Throttling(err.msg))
4126                }
4127                "ValidationException" => return RusotoError::Validation(err.msg),
4128                _ => {}
4129            }
4130        }
4131        RusotoError::Unknown(res)
4132    }
4133}
4134impl fmt::Display for ListSimulationJobsError {
4135    #[allow(unused_variables)]
4136    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4137        match *self {
4138            ListSimulationJobsError::InternalServer(ref cause) => write!(f, "{}", cause),
4139            ListSimulationJobsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
4140            ListSimulationJobsError::Throttling(ref cause) => write!(f, "{}", cause),
4141        }
4142    }
4143}
4144impl Error for ListSimulationJobsError {}
4145/// Errors returned by ListTagsForResource
4146#[derive(Debug, PartialEq)]
4147pub enum ListTagsForResourceError {
4148    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
4149    InternalServer(String),
4150    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
4151    InvalidParameter(String),
4152    /// <p>The specified resource does not exist.</p>
4153    ResourceNotFound(String),
4154    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
4155    Throttling(String),
4156}
4157
4158impl ListTagsForResourceError {
4159    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
4160        if let Some(err) = proto::json::Error::parse_rest(&res) {
4161            match err.typ.as_str() {
4162                "InternalServerException" => {
4163                    return RusotoError::Service(ListTagsForResourceError::InternalServer(err.msg))
4164                }
4165                "InvalidParameterException" => {
4166                    return RusotoError::Service(ListTagsForResourceError::InvalidParameter(
4167                        err.msg,
4168                    ))
4169                }
4170                "ResourceNotFoundException" => {
4171                    return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
4172                        err.msg,
4173                    ))
4174                }
4175                "ThrottlingException" => {
4176                    return RusotoError::Service(ListTagsForResourceError::Throttling(err.msg))
4177                }
4178                "ValidationException" => return RusotoError::Validation(err.msg),
4179                _ => {}
4180            }
4181        }
4182        RusotoError::Unknown(res)
4183    }
4184}
4185impl fmt::Display for ListTagsForResourceError {
4186    #[allow(unused_variables)]
4187    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4188        match *self {
4189            ListTagsForResourceError::InternalServer(ref cause) => write!(f, "{}", cause),
4190            ListTagsForResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
4191            ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
4192            ListTagsForResourceError::Throttling(ref cause) => write!(f, "{}", cause),
4193        }
4194    }
4195}
4196impl Error for ListTagsForResourceError {}
4197/// Errors returned by RegisterRobot
4198#[derive(Debug, PartialEq)]
4199pub enum RegisterRobotError {
4200    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
4201    InternalServer(String),
4202    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
4203    InvalidParameter(String),
4204    /// <p>The requested resource exceeds the maximum number allowed, or the number of concurrent stream requests exceeds the maximum number allowed. </p>
4205    LimitExceeded(String),
4206    /// <p>The specified resource does not exist.</p>
4207    ResourceNotFound(String),
4208    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
4209    Throttling(String),
4210}
4211
4212impl RegisterRobotError {
4213    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RegisterRobotError> {
4214        if let Some(err) = proto::json::Error::parse_rest(&res) {
4215            match err.typ.as_str() {
4216                "InternalServerException" => {
4217                    return RusotoError::Service(RegisterRobotError::InternalServer(err.msg))
4218                }
4219                "InvalidParameterException" => {
4220                    return RusotoError::Service(RegisterRobotError::InvalidParameter(err.msg))
4221                }
4222                "LimitExceededException" => {
4223                    return RusotoError::Service(RegisterRobotError::LimitExceeded(err.msg))
4224                }
4225                "ResourceNotFoundException" => {
4226                    return RusotoError::Service(RegisterRobotError::ResourceNotFound(err.msg))
4227                }
4228                "ThrottlingException" => {
4229                    return RusotoError::Service(RegisterRobotError::Throttling(err.msg))
4230                }
4231                "ValidationException" => return RusotoError::Validation(err.msg),
4232                _ => {}
4233            }
4234        }
4235        RusotoError::Unknown(res)
4236    }
4237}
4238impl fmt::Display for RegisterRobotError {
4239    #[allow(unused_variables)]
4240    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4241        match *self {
4242            RegisterRobotError::InternalServer(ref cause) => write!(f, "{}", cause),
4243            RegisterRobotError::InvalidParameter(ref cause) => write!(f, "{}", cause),
4244            RegisterRobotError::LimitExceeded(ref cause) => write!(f, "{}", cause),
4245            RegisterRobotError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
4246            RegisterRobotError::Throttling(ref cause) => write!(f, "{}", cause),
4247        }
4248    }
4249}
4250impl Error for RegisterRobotError {}
4251/// Errors returned by RestartSimulationJob
4252#[derive(Debug, PartialEq)]
4253pub enum RestartSimulationJobError {
4254    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
4255    InternalServer(String),
4256    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
4257    InvalidParameter(String),
4258    /// <p>The requested resource exceeds the maximum number allowed, or the number of concurrent stream requests exceeds the maximum number allowed. </p>
4259    LimitExceeded(String),
4260    /// <p>The specified resource does not exist.</p>
4261    ResourceNotFound(String),
4262    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
4263    Throttling(String),
4264}
4265
4266impl RestartSimulationJobError {
4267    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RestartSimulationJobError> {
4268        if let Some(err) = proto::json::Error::parse_rest(&res) {
4269            match err.typ.as_str() {
4270                "InternalServerException" => {
4271                    return RusotoError::Service(RestartSimulationJobError::InternalServer(err.msg))
4272                }
4273                "InvalidParameterException" => {
4274                    return RusotoError::Service(RestartSimulationJobError::InvalidParameter(
4275                        err.msg,
4276                    ))
4277                }
4278                "LimitExceededException" => {
4279                    return RusotoError::Service(RestartSimulationJobError::LimitExceeded(err.msg))
4280                }
4281                "ResourceNotFoundException" => {
4282                    return RusotoError::Service(RestartSimulationJobError::ResourceNotFound(
4283                        err.msg,
4284                    ))
4285                }
4286                "ThrottlingException" => {
4287                    return RusotoError::Service(RestartSimulationJobError::Throttling(err.msg))
4288                }
4289                "ValidationException" => return RusotoError::Validation(err.msg),
4290                _ => {}
4291            }
4292        }
4293        RusotoError::Unknown(res)
4294    }
4295}
4296impl fmt::Display for RestartSimulationJobError {
4297    #[allow(unused_variables)]
4298    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4299        match *self {
4300            RestartSimulationJobError::InternalServer(ref cause) => write!(f, "{}", cause),
4301            RestartSimulationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
4302            RestartSimulationJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
4303            RestartSimulationJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
4304            RestartSimulationJobError::Throttling(ref cause) => write!(f, "{}", cause),
4305        }
4306    }
4307}
4308impl Error for RestartSimulationJobError {}
4309/// Errors returned by StartSimulationJobBatch
4310#[derive(Debug, PartialEq)]
4311pub enum StartSimulationJobBatchError {
4312    /// <p>The request uses the same client token as a previous, but non-identical request. Do not reuse a client token with different requests, unless the requests are identical. </p>
4313    IdempotentParameterMismatch(String),
4314    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
4315    InternalServer(String),
4316    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
4317    InvalidParameter(String),
4318    /// <p>The requested resource exceeds the maximum number allowed, or the number of concurrent stream requests exceeds the maximum number allowed. </p>
4319    LimitExceeded(String),
4320    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
4321    Throttling(String),
4322}
4323
4324impl StartSimulationJobBatchError {
4325    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartSimulationJobBatchError> {
4326        if let Some(err) = proto::json::Error::parse_rest(&res) {
4327            match err.typ.as_str() {
4328                "IdempotentParameterMismatchException" => {
4329                    return RusotoError::Service(
4330                        StartSimulationJobBatchError::IdempotentParameterMismatch(err.msg),
4331                    )
4332                }
4333                "InternalServerException" => {
4334                    return RusotoError::Service(StartSimulationJobBatchError::InternalServer(
4335                        err.msg,
4336                    ))
4337                }
4338                "InvalidParameterException" => {
4339                    return RusotoError::Service(StartSimulationJobBatchError::InvalidParameter(
4340                        err.msg,
4341                    ))
4342                }
4343                "LimitExceededException" => {
4344                    return RusotoError::Service(StartSimulationJobBatchError::LimitExceeded(
4345                        err.msg,
4346                    ))
4347                }
4348                "ThrottlingException" => {
4349                    return RusotoError::Service(StartSimulationJobBatchError::Throttling(err.msg))
4350                }
4351                "ValidationException" => return RusotoError::Validation(err.msg),
4352                _ => {}
4353            }
4354        }
4355        RusotoError::Unknown(res)
4356    }
4357}
4358impl fmt::Display for StartSimulationJobBatchError {
4359    #[allow(unused_variables)]
4360    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4361        match *self {
4362            StartSimulationJobBatchError::IdempotentParameterMismatch(ref cause) => {
4363                write!(f, "{}", cause)
4364            }
4365            StartSimulationJobBatchError::InternalServer(ref cause) => write!(f, "{}", cause),
4366            StartSimulationJobBatchError::InvalidParameter(ref cause) => write!(f, "{}", cause),
4367            StartSimulationJobBatchError::LimitExceeded(ref cause) => write!(f, "{}", cause),
4368            StartSimulationJobBatchError::Throttling(ref cause) => write!(f, "{}", cause),
4369        }
4370    }
4371}
4372impl Error for StartSimulationJobBatchError {}
4373/// Errors returned by SyncDeploymentJob
4374#[derive(Debug, PartialEq)]
4375pub enum SyncDeploymentJobError {
4376    /// <p>The failure percentage threshold percentage was met.</p>
4377    ConcurrentDeployment(String),
4378    /// <p>The request uses the same client token as a previous, but non-identical request. Do not reuse a client token with different requests, unless the requests are identical. </p>
4379    IdempotentParameterMismatch(String),
4380    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
4381    InternalServer(String),
4382    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
4383    InvalidParameter(String),
4384    /// <p>The requested resource exceeds the maximum number allowed, or the number of concurrent stream requests exceeds the maximum number allowed. </p>
4385    LimitExceeded(String),
4386    /// <p>The specified resource does not exist.</p>
4387    ResourceNotFound(String),
4388    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
4389    Throttling(String),
4390}
4391
4392impl SyncDeploymentJobError {
4393    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SyncDeploymentJobError> {
4394        if let Some(err) = proto::json::Error::parse_rest(&res) {
4395            match err.typ.as_str() {
4396                "ConcurrentDeploymentException" => {
4397                    return RusotoError::Service(SyncDeploymentJobError::ConcurrentDeployment(
4398                        err.msg,
4399                    ))
4400                }
4401                "IdempotentParameterMismatchException" => {
4402                    return RusotoError::Service(
4403                        SyncDeploymentJobError::IdempotentParameterMismatch(err.msg),
4404                    )
4405                }
4406                "InternalServerException" => {
4407                    return RusotoError::Service(SyncDeploymentJobError::InternalServer(err.msg))
4408                }
4409                "InvalidParameterException" => {
4410                    return RusotoError::Service(SyncDeploymentJobError::InvalidParameter(err.msg))
4411                }
4412                "LimitExceededException" => {
4413                    return RusotoError::Service(SyncDeploymentJobError::LimitExceeded(err.msg))
4414                }
4415                "ResourceNotFoundException" => {
4416                    return RusotoError::Service(SyncDeploymentJobError::ResourceNotFound(err.msg))
4417                }
4418                "ThrottlingException" => {
4419                    return RusotoError::Service(SyncDeploymentJobError::Throttling(err.msg))
4420                }
4421                "ValidationException" => return RusotoError::Validation(err.msg),
4422                _ => {}
4423            }
4424        }
4425        RusotoError::Unknown(res)
4426    }
4427}
4428impl fmt::Display for SyncDeploymentJobError {
4429    #[allow(unused_variables)]
4430    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4431        match *self {
4432            SyncDeploymentJobError::ConcurrentDeployment(ref cause) => write!(f, "{}", cause),
4433            SyncDeploymentJobError::IdempotentParameterMismatch(ref cause) => {
4434                write!(f, "{}", cause)
4435            }
4436            SyncDeploymentJobError::InternalServer(ref cause) => write!(f, "{}", cause),
4437            SyncDeploymentJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
4438            SyncDeploymentJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
4439            SyncDeploymentJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
4440            SyncDeploymentJobError::Throttling(ref cause) => write!(f, "{}", cause),
4441        }
4442    }
4443}
4444impl Error for SyncDeploymentJobError {}
4445/// Errors returned by TagResource
4446#[derive(Debug, PartialEq)]
4447pub enum TagResourceError {
4448    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
4449    InternalServer(String),
4450    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
4451    InvalidParameter(String),
4452    /// <p>The specified resource does not exist.</p>
4453    ResourceNotFound(String),
4454    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
4455    Throttling(String),
4456}
4457
4458impl TagResourceError {
4459    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
4460        if let Some(err) = proto::json::Error::parse_rest(&res) {
4461            match err.typ.as_str() {
4462                "InternalServerException" => {
4463                    return RusotoError::Service(TagResourceError::InternalServer(err.msg))
4464                }
4465                "InvalidParameterException" => {
4466                    return RusotoError::Service(TagResourceError::InvalidParameter(err.msg))
4467                }
4468                "ResourceNotFoundException" => {
4469                    return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
4470                }
4471                "ThrottlingException" => {
4472                    return RusotoError::Service(TagResourceError::Throttling(err.msg))
4473                }
4474                "ValidationException" => return RusotoError::Validation(err.msg),
4475                _ => {}
4476            }
4477        }
4478        RusotoError::Unknown(res)
4479    }
4480}
4481impl fmt::Display for TagResourceError {
4482    #[allow(unused_variables)]
4483    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4484        match *self {
4485            TagResourceError::InternalServer(ref cause) => write!(f, "{}", cause),
4486            TagResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
4487            TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
4488            TagResourceError::Throttling(ref cause) => write!(f, "{}", cause),
4489        }
4490    }
4491}
4492impl Error for TagResourceError {}
4493/// Errors returned by UntagResource
4494#[derive(Debug, PartialEq)]
4495pub enum UntagResourceError {
4496    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
4497    InternalServer(String),
4498    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
4499    InvalidParameter(String),
4500    /// <p>The specified resource does not exist.</p>
4501    ResourceNotFound(String),
4502    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
4503    Throttling(String),
4504}
4505
4506impl UntagResourceError {
4507    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
4508        if let Some(err) = proto::json::Error::parse_rest(&res) {
4509            match err.typ.as_str() {
4510                "InternalServerException" => {
4511                    return RusotoError::Service(UntagResourceError::InternalServer(err.msg))
4512                }
4513                "InvalidParameterException" => {
4514                    return RusotoError::Service(UntagResourceError::InvalidParameter(err.msg))
4515                }
4516                "ResourceNotFoundException" => {
4517                    return RusotoError::Service(UntagResourceError::ResourceNotFound(err.msg))
4518                }
4519                "ThrottlingException" => {
4520                    return RusotoError::Service(UntagResourceError::Throttling(err.msg))
4521                }
4522                "ValidationException" => return RusotoError::Validation(err.msg),
4523                _ => {}
4524            }
4525        }
4526        RusotoError::Unknown(res)
4527    }
4528}
4529impl fmt::Display for UntagResourceError {
4530    #[allow(unused_variables)]
4531    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4532        match *self {
4533            UntagResourceError::InternalServer(ref cause) => write!(f, "{}", cause),
4534            UntagResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
4535            UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
4536            UntagResourceError::Throttling(ref cause) => write!(f, "{}", cause),
4537        }
4538    }
4539}
4540impl Error for UntagResourceError {}
4541/// Errors returned by UpdateRobotApplication
4542#[derive(Debug, PartialEq)]
4543pub enum UpdateRobotApplicationError {
4544    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
4545    InternalServer(String),
4546    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
4547    InvalidParameter(String),
4548    /// <p>The requested resource exceeds the maximum number allowed, or the number of concurrent stream requests exceeds the maximum number allowed. </p>
4549    LimitExceeded(String),
4550    /// <p>The specified resource does not exist.</p>
4551    ResourceNotFound(String),
4552    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
4553    Throttling(String),
4554}
4555
4556impl UpdateRobotApplicationError {
4557    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateRobotApplicationError> {
4558        if let Some(err) = proto::json::Error::parse_rest(&res) {
4559            match err.typ.as_str() {
4560                "InternalServerException" => {
4561                    return RusotoError::Service(UpdateRobotApplicationError::InternalServer(
4562                        err.msg,
4563                    ))
4564                }
4565                "InvalidParameterException" => {
4566                    return RusotoError::Service(UpdateRobotApplicationError::InvalidParameter(
4567                        err.msg,
4568                    ))
4569                }
4570                "LimitExceededException" => {
4571                    return RusotoError::Service(UpdateRobotApplicationError::LimitExceeded(
4572                        err.msg,
4573                    ))
4574                }
4575                "ResourceNotFoundException" => {
4576                    return RusotoError::Service(UpdateRobotApplicationError::ResourceNotFound(
4577                        err.msg,
4578                    ))
4579                }
4580                "ThrottlingException" => {
4581                    return RusotoError::Service(UpdateRobotApplicationError::Throttling(err.msg))
4582                }
4583                "ValidationException" => return RusotoError::Validation(err.msg),
4584                _ => {}
4585            }
4586        }
4587        RusotoError::Unknown(res)
4588    }
4589}
4590impl fmt::Display for UpdateRobotApplicationError {
4591    #[allow(unused_variables)]
4592    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4593        match *self {
4594            UpdateRobotApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
4595            UpdateRobotApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
4596            UpdateRobotApplicationError::LimitExceeded(ref cause) => write!(f, "{}", cause),
4597            UpdateRobotApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
4598            UpdateRobotApplicationError::Throttling(ref cause) => write!(f, "{}", cause),
4599        }
4600    }
4601}
4602impl Error for UpdateRobotApplicationError {}
4603/// Errors returned by UpdateSimulationApplication
4604#[derive(Debug, PartialEq)]
4605pub enum UpdateSimulationApplicationError {
4606    /// <p>AWS RoboMaker experienced a service issue. Try your call again.</p>
4607    InternalServer(String),
4608    /// <p>A parameter specified in a request is not valid, is unsupported, or cannot be used. The returned message provides an explanation of the error value.</p>
4609    InvalidParameter(String),
4610    /// <p>The requested resource exceeds the maximum number allowed, or the number of concurrent stream requests exceeds the maximum number allowed. </p>
4611    LimitExceeded(String),
4612    /// <p>The specified resource does not exist.</p>
4613    ResourceNotFound(String),
4614    /// <p>AWS RoboMaker is temporarily unable to process the request. Try your call again.</p>
4615    Throttling(String),
4616}
4617
4618impl UpdateSimulationApplicationError {
4619    pub fn from_response(
4620        res: BufferedHttpResponse,
4621    ) -> RusotoError<UpdateSimulationApplicationError> {
4622        if let Some(err) = proto::json::Error::parse_rest(&res) {
4623            match err.typ.as_str() {
4624                "InternalServerException" => {
4625                    return RusotoError::Service(UpdateSimulationApplicationError::InternalServer(
4626                        err.msg,
4627                    ))
4628                }
4629                "InvalidParameterException" => {
4630                    return RusotoError::Service(
4631                        UpdateSimulationApplicationError::InvalidParameter(err.msg),
4632                    )
4633                }
4634                "LimitExceededException" => {
4635                    return RusotoError::Service(UpdateSimulationApplicationError::LimitExceeded(
4636                        err.msg,
4637                    ))
4638                }
4639                "ResourceNotFoundException" => {
4640                    return RusotoError::Service(
4641                        UpdateSimulationApplicationError::ResourceNotFound(err.msg),
4642                    )
4643                }
4644                "ThrottlingException" => {
4645                    return RusotoError::Service(UpdateSimulationApplicationError::Throttling(
4646                        err.msg,
4647                    ))
4648                }
4649                "ValidationException" => return RusotoError::Validation(err.msg),
4650                _ => {}
4651            }
4652        }
4653        RusotoError::Unknown(res)
4654    }
4655}
4656impl fmt::Display for UpdateSimulationApplicationError {
4657    #[allow(unused_variables)]
4658    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4659        match *self {
4660            UpdateSimulationApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
4661            UpdateSimulationApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
4662            UpdateSimulationApplicationError::LimitExceeded(ref cause) => write!(f, "{}", cause),
4663            UpdateSimulationApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
4664            UpdateSimulationApplicationError::Throttling(ref cause) => write!(f, "{}", cause),
4665        }
4666    }
4667}
4668impl Error for UpdateSimulationApplicationError {}
4669/// Trait representing the capabilities of the RoboMaker API. RoboMaker clients implement this trait.
4670#[async_trait]
4671pub trait Robomaker {
4672    /// <p>Describes one or more simulation jobs.</p>
4673    async fn batch_describe_simulation_job(
4674        &self,
4675        input: BatchDescribeSimulationJobRequest,
4676    ) -> Result<BatchDescribeSimulationJobResponse, RusotoError<BatchDescribeSimulationJobError>>;
4677
4678    /// <p>Cancels the specified deployment job.</p>
4679    async fn cancel_deployment_job(
4680        &self,
4681        input: CancelDeploymentJobRequest,
4682    ) -> Result<CancelDeploymentJobResponse, RusotoError<CancelDeploymentJobError>>;
4683
4684    /// <p>Cancels the specified simulation job.</p>
4685    async fn cancel_simulation_job(
4686        &self,
4687        input: CancelSimulationJobRequest,
4688    ) -> Result<CancelSimulationJobResponse, RusotoError<CancelSimulationJobError>>;
4689
4690    /// <p>Cancels a simulation job batch. When you cancel a simulation job batch, you are also cancelling all of the active simulation jobs created as part of the batch. </p>
4691    async fn cancel_simulation_job_batch(
4692        &self,
4693        input: CancelSimulationJobBatchRequest,
4694    ) -> Result<CancelSimulationJobBatchResponse, RusotoError<CancelSimulationJobBatchError>>;
4695
4696    /// <p><p>Deploys a specific version of a robot application to robots in a fleet.</p> <p>The robot application must have a numbered <code>applicationVersion</code> for consistency reasons. To create a new version, use <code>CreateRobotApplicationVersion</code> or see <a href="https://docs.aws.amazon.com/robomaker/latest/dg/create-robot-application-version.html">Creating a Robot Application Version</a>. </p> <note> <p>After 90 days, deployment jobs expire and will be deleted. They will no longer be accessible. </p> </note></p>
4697    async fn create_deployment_job(
4698        &self,
4699        input: CreateDeploymentJobRequest,
4700    ) -> Result<CreateDeploymentJobResponse, RusotoError<CreateDeploymentJobError>>;
4701
4702    /// <p>Creates a fleet, a logical group of robots running the same robot application.</p>
4703    async fn create_fleet(
4704        &self,
4705        input: CreateFleetRequest,
4706    ) -> Result<CreateFleetResponse, RusotoError<CreateFleetError>>;
4707
4708    /// <p>Creates a robot.</p>
4709    async fn create_robot(
4710        &self,
4711        input: CreateRobotRequest,
4712    ) -> Result<CreateRobotResponse, RusotoError<CreateRobotError>>;
4713
4714    /// <p>Creates a robot application. </p>
4715    async fn create_robot_application(
4716        &self,
4717        input: CreateRobotApplicationRequest,
4718    ) -> Result<CreateRobotApplicationResponse, RusotoError<CreateRobotApplicationError>>;
4719
4720    /// <p>Creates a version of a robot application.</p>
4721    async fn create_robot_application_version(
4722        &self,
4723        input: CreateRobotApplicationVersionRequest,
4724    ) -> Result<
4725        CreateRobotApplicationVersionResponse,
4726        RusotoError<CreateRobotApplicationVersionError>,
4727    >;
4728
4729    /// <p>Creates a simulation application.</p>
4730    async fn create_simulation_application(
4731        &self,
4732        input: CreateSimulationApplicationRequest,
4733    ) -> Result<CreateSimulationApplicationResponse, RusotoError<CreateSimulationApplicationError>>;
4734
4735    /// <p>Creates a simulation application with a specific revision id.</p>
4736    async fn create_simulation_application_version(
4737        &self,
4738        input: CreateSimulationApplicationVersionRequest,
4739    ) -> Result<
4740        CreateSimulationApplicationVersionResponse,
4741        RusotoError<CreateSimulationApplicationVersionError>,
4742    >;
4743
4744    /// <p><p>Creates a simulation job.</p> <note> <p>After 90 days, simulation jobs expire and will be deleted. They will no longer be accessible. </p> </note></p>
4745    async fn create_simulation_job(
4746        &self,
4747        input: CreateSimulationJobRequest,
4748    ) -> Result<CreateSimulationJobResponse, RusotoError<CreateSimulationJobError>>;
4749
4750    /// <p>Deletes a fleet.</p>
4751    async fn delete_fleet(
4752        &self,
4753        input: DeleteFleetRequest,
4754    ) -> Result<DeleteFleetResponse, RusotoError<DeleteFleetError>>;
4755
4756    /// <p>Deletes a robot.</p>
4757    async fn delete_robot(
4758        &self,
4759        input: DeleteRobotRequest,
4760    ) -> Result<DeleteRobotResponse, RusotoError<DeleteRobotError>>;
4761
4762    /// <p>Deletes a robot application.</p>
4763    async fn delete_robot_application(
4764        &self,
4765        input: DeleteRobotApplicationRequest,
4766    ) -> Result<DeleteRobotApplicationResponse, RusotoError<DeleteRobotApplicationError>>;
4767
4768    /// <p>Deletes a simulation application.</p>
4769    async fn delete_simulation_application(
4770        &self,
4771        input: DeleteSimulationApplicationRequest,
4772    ) -> Result<DeleteSimulationApplicationResponse, RusotoError<DeleteSimulationApplicationError>>;
4773
4774    /// <p>Deregisters a robot.</p>
4775    async fn deregister_robot(
4776        &self,
4777        input: DeregisterRobotRequest,
4778    ) -> Result<DeregisterRobotResponse, RusotoError<DeregisterRobotError>>;
4779
4780    /// <p>Describes a deployment job.</p>
4781    async fn describe_deployment_job(
4782        &self,
4783        input: DescribeDeploymentJobRequest,
4784    ) -> Result<DescribeDeploymentJobResponse, RusotoError<DescribeDeploymentJobError>>;
4785
4786    /// <p>Describes a fleet.</p>
4787    async fn describe_fleet(
4788        &self,
4789        input: DescribeFleetRequest,
4790    ) -> Result<DescribeFleetResponse, RusotoError<DescribeFleetError>>;
4791
4792    /// <p>Describes a robot.</p>
4793    async fn describe_robot(
4794        &self,
4795        input: DescribeRobotRequest,
4796    ) -> Result<DescribeRobotResponse, RusotoError<DescribeRobotError>>;
4797
4798    /// <p>Describes a robot application.</p>
4799    async fn describe_robot_application(
4800        &self,
4801        input: DescribeRobotApplicationRequest,
4802    ) -> Result<DescribeRobotApplicationResponse, RusotoError<DescribeRobotApplicationError>>;
4803
4804    /// <p>Describes a simulation application.</p>
4805    async fn describe_simulation_application(
4806        &self,
4807        input: DescribeSimulationApplicationRequest,
4808    ) -> Result<
4809        DescribeSimulationApplicationResponse,
4810        RusotoError<DescribeSimulationApplicationError>,
4811    >;
4812
4813    /// <p>Describes a simulation job.</p>
4814    async fn describe_simulation_job(
4815        &self,
4816        input: DescribeSimulationJobRequest,
4817    ) -> Result<DescribeSimulationJobResponse, RusotoError<DescribeSimulationJobError>>;
4818
4819    /// <p>Describes a simulation job batch.</p>
4820    async fn describe_simulation_job_batch(
4821        &self,
4822        input: DescribeSimulationJobBatchRequest,
4823    ) -> Result<DescribeSimulationJobBatchResponse, RusotoError<DescribeSimulationJobBatchError>>;
4824
4825    /// <p>Returns a list of deployment jobs for a fleet. You can optionally provide filters to retrieve specific deployment jobs. </p>
4826    async fn list_deployment_jobs(
4827        &self,
4828        input: ListDeploymentJobsRequest,
4829    ) -> Result<ListDeploymentJobsResponse, RusotoError<ListDeploymentJobsError>>;
4830
4831    /// <p>Returns a list of fleets. You can optionally provide filters to retrieve specific fleets. </p>
4832    async fn list_fleets(
4833        &self,
4834        input: ListFleetsRequest,
4835    ) -> Result<ListFleetsResponse, RusotoError<ListFleetsError>>;
4836
4837    /// <p>Returns a list of robot application. You can optionally provide filters to retrieve specific robot applications.</p>
4838    async fn list_robot_applications(
4839        &self,
4840        input: ListRobotApplicationsRequest,
4841    ) -> Result<ListRobotApplicationsResponse, RusotoError<ListRobotApplicationsError>>;
4842
4843    /// <p>Returns a list of robots. You can optionally provide filters to retrieve specific robots.</p>
4844    async fn list_robots(
4845        &self,
4846        input: ListRobotsRequest,
4847    ) -> Result<ListRobotsResponse, RusotoError<ListRobotsError>>;
4848
4849    /// <p>Returns a list of simulation applications. You can optionally provide filters to retrieve specific simulation applications. </p>
4850    async fn list_simulation_applications(
4851        &self,
4852        input: ListSimulationApplicationsRequest,
4853    ) -> Result<ListSimulationApplicationsResponse, RusotoError<ListSimulationApplicationsError>>;
4854
4855    /// <p>Returns a list simulation job batches. You can optionally provide filters to retrieve specific simulation batch jobs. </p>
4856    async fn list_simulation_job_batches(
4857        &self,
4858        input: ListSimulationJobBatchesRequest,
4859    ) -> Result<ListSimulationJobBatchesResponse, RusotoError<ListSimulationJobBatchesError>>;
4860
4861    /// <p>Returns a list of simulation jobs. You can optionally provide filters to retrieve specific simulation jobs. </p>
4862    async fn list_simulation_jobs(
4863        &self,
4864        input: ListSimulationJobsRequest,
4865    ) -> Result<ListSimulationJobsResponse, RusotoError<ListSimulationJobsError>>;
4866
4867    /// <p>Lists all tags on a AWS RoboMaker resource.</p>
4868    async fn list_tags_for_resource(
4869        &self,
4870        input: ListTagsForResourceRequest,
4871    ) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
4872
4873    /// <p>Registers a robot with a fleet.</p>
4874    async fn register_robot(
4875        &self,
4876        input: RegisterRobotRequest,
4877    ) -> Result<RegisterRobotResponse, RusotoError<RegisterRobotError>>;
4878
4879    /// <p>Restarts a running simulation job.</p>
4880    async fn restart_simulation_job(
4881        &self,
4882        input: RestartSimulationJobRequest,
4883    ) -> Result<RestartSimulationJobResponse, RusotoError<RestartSimulationJobError>>;
4884
4885    /// <p>Starts a new simulation job batch. The batch is defined using one or more <code>SimulationJobRequest</code> objects. </p>
4886    async fn start_simulation_job_batch(
4887        &self,
4888        input: StartSimulationJobBatchRequest,
4889    ) -> Result<StartSimulationJobBatchResponse, RusotoError<StartSimulationJobBatchError>>;
4890
4891    /// <p>Syncrhonizes robots in a fleet to the latest deployment. This is helpful if robots were added after a deployment.</p>
4892    async fn sync_deployment_job(
4893        &self,
4894        input: SyncDeploymentJobRequest,
4895    ) -> Result<SyncDeploymentJobResponse, RusotoError<SyncDeploymentJobError>>;
4896
4897    /// <p>Adds or edits tags for a AWS RoboMaker resource.</p> <p>Each tag consists of a tag key and a tag value. Tag keys and tag values are both required, but tag values can be empty strings. </p> <p>For information about the rules that apply to tag keys and tag values, see <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/allocation-tag-restrictions.html">User-Defined Tag Restrictions</a> in the <i>AWS Billing and Cost Management User Guide</i>. </p>
4898    async fn tag_resource(
4899        &self,
4900        input: TagResourceRequest,
4901    ) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
4902
4903    /// <p>Removes the specified tags from the specified AWS RoboMaker resource.</p> <p>To remove a tag, specify the tag key. To change the tag value of an existing tag key, use <a href="https://docs.aws.amazon.com/robomaker/latest/dg/API_TagResource.html"> <code>TagResource</code> </a>. </p>
4904    async fn untag_resource(
4905        &self,
4906        input: UntagResourceRequest,
4907    ) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
4908
4909    /// <p>Updates a robot application.</p>
4910    async fn update_robot_application(
4911        &self,
4912        input: UpdateRobotApplicationRequest,
4913    ) -> Result<UpdateRobotApplicationResponse, RusotoError<UpdateRobotApplicationError>>;
4914
4915    /// <p>Updates a simulation application.</p>
4916    async fn update_simulation_application(
4917        &self,
4918        input: UpdateSimulationApplicationRequest,
4919    ) -> Result<UpdateSimulationApplicationResponse, RusotoError<UpdateSimulationApplicationError>>;
4920}
4921/// A client for the RoboMaker API.
4922#[derive(Clone)]
4923pub struct RobomakerClient {
4924    client: Client,
4925    region: region::Region,
4926}
4927
4928impl RobomakerClient {
4929    /// Creates a client backed by the default tokio event loop.
4930    ///
4931    /// The client will use the default credentials provider and tls client.
4932    pub fn new(region: region::Region) -> RobomakerClient {
4933        RobomakerClient {
4934            client: Client::shared(),
4935            region,
4936        }
4937    }
4938
4939    pub fn new_with<P, D>(
4940        request_dispatcher: D,
4941        credentials_provider: P,
4942        region: region::Region,
4943    ) -> RobomakerClient
4944    where
4945        P: ProvideAwsCredentials + Send + Sync + 'static,
4946        D: DispatchSignedRequest + Send + Sync + 'static,
4947    {
4948        RobomakerClient {
4949            client: Client::new_with(credentials_provider, request_dispatcher),
4950            region,
4951        }
4952    }
4953
4954    pub fn new_with_client(client: Client, region: region::Region) -> RobomakerClient {
4955        RobomakerClient { client, region }
4956    }
4957}
4958
4959#[async_trait]
4960impl Robomaker for RobomakerClient {
4961    /// <p>Describes one or more simulation jobs.</p>
4962    #[allow(unused_mut)]
4963    async fn batch_describe_simulation_job(
4964        &self,
4965        input: BatchDescribeSimulationJobRequest,
4966    ) -> Result<BatchDescribeSimulationJobResponse, RusotoError<BatchDescribeSimulationJobError>>
4967    {
4968        let request_uri = "/batchDescribeSimulationJob";
4969
4970        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
4971        request.set_content_type("application/x-amz-json-1.1".to_owned());
4972
4973        let encoded = Some(serde_json::to_vec(&input).unwrap());
4974        request.set_payload(encoded);
4975
4976        let mut response = self
4977            .client
4978            .sign_and_dispatch(request)
4979            .await
4980            .map_err(RusotoError::from)?;
4981        if response.status.is_success() {
4982            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4983            let result = proto::json::ResponsePayload::new(&response)
4984                .deserialize::<BatchDescribeSimulationJobResponse, _>()?;
4985
4986            Ok(result)
4987        } else {
4988            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4989            Err(BatchDescribeSimulationJobError::from_response(response))
4990        }
4991    }
4992
4993    /// <p>Cancels the specified deployment job.</p>
4994    #[allow(unused_mut)]
4995    async fn cancel_deployment_job(
4996        &self,
4997        input: CancelDeploymentJobRequest,
4998    ) -> Result<CancelDeploymentJobResponse, RusotoError<CancelDeploymentJobError>> {
4999        let request_uri = "/cancelDeploymentJob";
5000
5001        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5002        request.set_content_type("application/x-amz-json-1.1".to_owned());
5003
5004        let encoded = Some(serde_json::to_vec(&input).unwrap());
5005        request.set_payload(encoded);
5006
5007        let mut response = self
5008            .client
5009            .sign_and_dispatch(request)
5010            .await
5011            .map_err(RusotoError::from)?;
5012        if response.status.is_success() {
5013            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5014            let result = proto::json::ResponsePayload::new(&response)
5015                .deserialize::<CancelDeploymentJobResponse, _>()?;
5016
5017            Ok(result)
5018        } else {
5019            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5020            Err(CancelDeploymentJobError::from_response(response))
5021        }
5022    }
5023
5024    /// <p>Cancels the specified simulation job.</p>
5025    #[allow(unused_mut)]
5026    async fn cancel_simulation_job(
5027        &self,
5028        input: CancelSimulationJobRequest,
5029    ) -> Result<CancelSimulationJobResponse, RusotoError<CancelSimulationJobError>> {
5030        let request_uri = "/cancelSimulationJob";
5031
5032        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5033        request.set_content_type("application/x-amz-json-1.1".to_owned());
5034
5035        let encoded = Some(serde_json::to_vec(&input).unwrap());
5036        request.set_payload(encoded);
5037
5038        let mut response = self
5039            .client
5040            .sign_and_dispatch(request)
5041            .await
5042            .map_err(RusotoError::from)?;
5043        if response.status.is_success() {
5044            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5045            let result = proto::json::ResponsePayload::new(&response)
5046                .deserialize::<CancelSimulationJobResponse, _>()?;
5047
5048            Ok(result)
5049        } else {
5050            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5051            Err(CancelSimulationJobError::from_response(response))
5052        }
5053    }
5054
5055    /// <p>Cancels a simulation job batch. When you cancel a simulation job batch, you are also cancelling all of the active simulation jobs created as part of the batch. </p>
5056    #[allow(unused_mut)]
5057    async fn cancel_simulation_job_batch(
5058        &self,
5059        input: CancelSimulationJobBatchRequest,
5060    ) -> Result<CancelSimulationJobBatchResponse, RusotoError<CancelSimulationJobBatchError>> {
5061        let request_uri = "/cancelSimulationJobBatch";
5062
5063        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5064        request.set_content_type("application/x-amz-json-1.1".to_owned());
5065
5066        let encoded = Some(serde_json::to_vec(&input).unwrap());
5067        request.set_payload(encoded);
5068
5069        let mut response = self
5070            .client
5071            .sign_and_dispatch(request)
5072            .await
5073            .map_err(RusotoError::from)?;
5074        if response.status.is_success() {
5075            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5076            let result = proto::json::ResponsePayload::new(&response)
5077                .deserialize::<CancelSimulationJobBatchResponse, _>()?;
5078
5079            Ok(result)
5080        } else {
5081            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5082            Err(CancelSimulationJobBatchError::from_response(response))
5083        }
5084    }
5085
5086    /// <p><p>Deploys a specific version of a robot application to robots in a fleet.</p> <p>The robot application must have a numbered <code>applicationVersion</code> for consistency reasons. To create a new version, use <code>CreateRobotApplicationVersion</code> or see <a href="https://docs.aws.amazon.com/robomaker/latest/dg/create-robot-application-version.html">Creating a Robot Application Version</a>. </p> <note> <p>After 90 days, deployment jobs expire and will be deleted. They will no longer be accessible. </p> </note></p>
5087    #[allow(unused_mut)]
5088    async fn create_deployment_job(
5089        &self,
5090        input: CreateDeploymentJobRequest,
5091    ) -> Result<CreateDeploymentJobResponse, RusotoError<CreateDeploymentJobError>> {
5092        let request_uri = "/createDeploymentJob";
5093
5094        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5095        request.set_content_type("application/x-amz-json-1.1".to_owned());
5096
5097        let encoded = Some(serde_json::to_vec(&input).unwrap());
5098        request.set_payload(encoded);
5099
5100        let mut response = self
5101            .client
5102            .sign_and_dispatch(request)
5103            .await
5104            .map_err(RusotoError::from)?;
5105        if response.status.is_success() {
5106            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5107            let result = proto::json::ResponsePayload::new(&response)
5108                .deserialize::<CreateDeploymentJobResponse, _>()?;
5109
5110            Ok(result)
5111        } else {
5112            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5113            Err(CreateDeploymentJobError::from_response(response))
5114        }
5115    }
5116
5117    /// <p>Creates a fleet, a logical group of robots running the same robot application.</p>
5118    #[allow(unused_mut)]
5119    async fn create_fleet(
5120        &self,
5121        input: CreateFleetRequest,
5122    ) -> Result<CreateFleetResponse, RusotoError<CreateFleetError>> {
5123        let request_uri = "/createFleet";
5124
5125        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5126        request.set_content_type("application/x-amz-json-1.1".to_owned());
5127
5128        let encoded = Some(serde_json::to_vec(&input).unwrap());
5129        request.set_payload(encoded);
5130
5131        let mut response = self
5132            .client
5133            .sign_and_dispatch(request)
5134            .await
5135            .map_err(RusotoError::from)?;
5136        if response.status.is_success() {
5137            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5138            let result = proto::json::ResponsePayload::new(&response)
5139                .deserialize::<CreateFleetResponse, _>()?;
5140
5141            Ok(result)
5142        } else {
5143            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5144            Err(CreateFleetError::from_response(response))
5145        }
5146    }
5147
5148    /// <p>Creates a robot.</p>
5149    #[allow(unused_mut)]
5150    async fn create_robot(
5151        &self,
5152        input: CreateRobotRequest,
5153    ) -> Result<CreateRobotResponse, RusotoError<CreateRobotError>> {
5154        let request_uri = "/createRobot";
5155
5156        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5157        request.set_content_type("application/x-amz-json-1.1".to_owned());
5158
5159        let encoded = Some(serde_json::to_vec(&input).unwrap());
5160        request.set_payload(encoded);
5161
5162        let mut response = self
5163            .client
5164            .sign_and_dispatch(request)
5165            .await
5166            .map_err(RusotoError::from)?;
5167        if response.status.is_success() {
5168            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5169            let result = proto::json::ResponsePayload::new(&response)
5170                .deserialize::<CreateRobotResponse, _>()?;
5171
5172            Ok(result)
5173        } else {
5174            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5175            Err(CreateRobotError::from_response(response))
5176        }
5177    }
5178
5179    /// <p>Creates a robot application. </p>
5180    #[allow(unused_mut)]
5181    async fn create_robot_application(
5182        &self,
5183        input: CreateRobotApplicationRequest,
5184    ) -> Result<CreateRobotApplicationResponse, RusotoError<CreateRobotApplicationError>> {
5185        let request_uri = "/createRobotApplication";
5186
5187        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5188        request.set_content_type("application/x-amz-json-1.1".to_owned());
5189
5190        let encoded = Some(serde_json::to_vec(&input).unwrap());
5191        request.set_payload(encoded);
5192
5193        let mut response = self
5194            .client
5195            .sign_and_dispatch(request)
5196            .await
5197            .map_err(RusotoError::from)?;
5198        if response.status.is_success() {
5199            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5200            let result = proto::json::ResponsePayload::new(&response)
5201                .deserialize::<CreateRobotApplicationResponse, _>()?;
5202
5203            Ok(result)
5204        } else {
5205            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5206            Err(CreateRobotApplicationError::from_response(response))
5207        }
5208    }
5209
5210    /// <p>Creates a version of a robot application.</p>
5211    #[allow(unused_mut)]
5212    async fn create_robot_application_version(
5213        &self,
5214        input: CreateRobotApplicationVersionRequest,
5215    ) -> Result<
5216        CreateRobotApplicationVersionResponse,
5217        RusotoError<CreateRobotApplicationVersionError>,
5218    > {
5219        let request_uri = "/createRobotApplicationVersion";
5220
5221        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5222        request.set_content_type("application/x-amz-json-1.1".to_owned());
5223
5224        let encoded = Some(serde_json::to_vec(&input).unwrap());
5225        request.set_payload(encoded);
5226
5227        let mut response = self
5228            .client
5229            .sign_and_dispatch(request)
5230            .await
5231            .map_err(RusotoError::from)?;
5232        if response.status.is_success() {
5233            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5234            let result = proto::json::ResponsePayload::new(&response)
5235                .deserialize::<CreateRobotApplicationVersionResponse, _>()?;
5236
5237            Ok(result)
5238        } else {
5239            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5240            Err(CreateRobotApplicationVersionError::from_response(response))
5241        }
5242    }
5243
5244    /// <p>Creates a simulation application.</p>
5245    #[allow(unused_mut)]
5246    async fn create_simulation_application(
5247        &self,
5248        input: CreateSimulationApplicationRequest,
5249    ) -> Result<CreateSimulationApplicationResponse, RusotoError<CreateSimulationApplicationError>>
5250    {
5251        let request_uri = "/createSimulationApplication";
5252
5253        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5254        request.set_content_type("application/x-amz-json-1.1".to_owned());
5255
5256        let encoded = Some(serde_json::to_vec(&input).unwrap());
5257        request.set_payload(encoded);
5258
5259        let mut response = self
5260            .client
5261            .sign_and_dispatch(request)
5262            .await
5263            .map_err(RusotoError::from)?;
5264        if response.status.is_success() {
5265            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5266            let result = proto::json::ResponsePayload::new(&response)
5267                .deserialize::<CreateSimulationApplicationResponse, _>()?;
5268
5269            Ok(result)
5270        } else {
5271            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5272            Err(CreateSimulationApplicationError::from_response(response))
5273        }
5274    }
5275
5276    /// <p>Creates a simulation application with a specific revision id.</p>
5277    #[allow(unused_mut)]
5278    async fn create_simulation_application_version(
5279        &self,
5280        input: CreateSimulationApplicationVersionRequest,
5281    ) -> Result<
5282        CreateSimulationApplicationVersionResponse,
5283        RusotoError<CreateSimulationApplicationVersionError>,
5284    > {
5285        let request_uri = "/createSimulationApplicationVersion";
5286
5287        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5288        request.set_content_type("application/x-amz-json-1.1".to_owned());
5289
5290        let encoded = Some(serde_json::to_vec(&input).unwrap());
5291        request.set_payload(encoded);
5292
5293        let mut response = self
5294            .client
5295            .sign_and_dispatch(request)
5296            .await
5297            .map_err(RusotoError::from)?;
5298        if response.status.is_success() {
5299            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5300            let result = proto::json::ResponsePayload::new(&response)
5301                .deserialize::<CreateSimulationApplicationVersionResponse, _>()?;
5302
5303            Ok(result)
5304        } else {
5305            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5306            Err(CreateSimulationApplicationVersionError::from_response(
5307                response,
5308            ))
5309        }
5310    }
5311
5312    /// <p><p>Creates a simulation job.</p> <note> <p>After 90 days, simulation jobs expire and will be deleted. They will no longer be accessible. </p> </note></p>
5313    #[allow(unused_mut)]
5314    async fn create_simulation_job(
5315        &self,
5316        input: CreateSimulationJobRequest,
5317    ) -> Result<CreateSimulationJobResponse, RusotoError<CreateSimulationJobError>> {
5318        let request_uri = "/createSimulationJob";
5319
5320        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5321        request.set_content_type("application/x-amz-json-1.1".to_owned());
5322
5323        let encoded = Some(serde_json::to_vec(&input).unwrap());
5324        request.set_payload(encoded);
5325
5326        let mut response = self
5327            .client
5328            .sign_and_dispatch(request)
5329            .await
5330            .map_err(RusotoError::from)?;
5331        if response.status.is_success() {
5332            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5333            let result = proto::json::ResponsePayload::new(&response)
5334                .deserialize::<CreateSimulationJobResponse, _>()?;
5335
5336            Ok(result)
5337        } else {
5338            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5339            Err(CreateSimulationJobError::from_response(response))
5340        }
5341    }
5342
5343    /// <p>Deletes a fleet.</p>
5344    #[allow(unused_mut)]
5345    async fn delete_fleet(
5346        &self,
5347        input: DeleteFleetRequest,
5348    ) -> Result<DeleteFleetResponse, RusotoError<DeleteFleetError>> {
5349        let request_uri = "/deleteFleet";
5350
5351        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5352        request.set_content_type("application/x-amz-json-1.1".to_owned());
5353
5354        let encoded = Some(serde_json::to_vec(&input).unwrap());
5355        request.set_payload(encoded);
5356
5357        let mut response = self
5358            .client
5359            .sign_and_dispatch(request)
5360            .await
5361            .map_err(RusotoError::from)?;
5362        if response.status.is_success() {
5363            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5364            let result = proto::json::ResponsePayload::new(&response)
5365                .deserialize::<DeleteFleetResponse, _>()?;
5366
5367            Ok(result)
5368        } else {
5369            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5370            Err(DeleteFleetError::from_response(response))
5371        }
5372    }
5373
5374    /// <p>Deletes a robot.</p>
5375    #[allow(unused_mut)]
5376    async fn delete_robot(
5377        &self,
5378        input: DeleteRobotRequest,
5379    ) -> Result<DeleteRobotResponse, RusotoError<DeleteRobotError>> {
5380        let request_uri = "/deleteRobot";
5381
5382        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5383        request.set_content_type("application/x-amz-json-1.1".to_owned());
5384
5385        let encoded = Some(serde_json::to_vec(&input).unwrap());
5386        request.set_payload(encoded);
5387
5388        let mut response = self
5389            .client
5390            .sign_and_dispatch(request)
5391            .await
5392            .map_err(RusotoError::from)?;
5393        if response.status.is_success() {
5394            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5395            let result = proto::json::ResponsePayload::new(&response)
5396                .deserialize::<DeleteRobotResponse, _>()?;
5397
5398            Ok(result)
5399        } else {
5400            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5401            Err(DeleteRobotError::from_response(response))
5402        }
5403    }
5404
5405    /// <p>Deletes a robot application.</p>
5406    #[allow(unused_mut)]
5407    async fn delete_robot_application(
5408        &self,
5409        input: DeleteRobotApplicationRequest,
5410    ) -> Result<DeleteRobotApplicationResponse, RusotoError<DeleteRobotApplicationError>> {
5411        let request_uri = "/deleteRobotApplication";
5412
5413        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5414        request.set_content_type("application/x-amz-json-1.1".to_owned());
5415
5416        let encoded = Some(serde_json::to_vec(&input).unwrap());
5417        request.set_payload(encoded);
5418
5419        let mut response = self
5420            .client
5421            .sign_and_dispatch(request)
5422            .await
5423            .map_err(RusotoError::from)?;
5424        if response.status.is_success() {
5425            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5426            let result = proto::json::ResponsePayload::new(&response)
5427                .deserialize::<DeleteRobotApplicationResponse, _>()?;
5428
5429            Ok(result)
5430        } else {
5431            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5432            Err(DeleteRobotApplicationError::from_response(response))
5433        }
5434    }
5435
5436    /// <p>Deletes a simulation application.</p>
5437    #[allow(unused_mut)]
5438    async fn delete_simulation_application(
5439        &self,
5440        input: DeleteSimulationApplicationRequest,
5441    ) -> Result<DeleteSimulationApplicationResponse, RusotoError<DeleteSimulationApplicationError>>
5442    {
5443        let request_uri = "/deleteSimulationApplication";
5444
5445        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5446        request.set_content_type("application/x-amz-json-1.1".to_owned());
5447
5448        let encoded = Some(serde_json::to_vec(&input).unwrap());
5449        request.set_payload(encoded);
5450
5451        let mut response = self
5452            .client
5453            .sign_and_dispatch(request)
5454            .await
5455            .map_err(RusotoError::from)?;
5456        if response.status.is_success() {
5457            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5458            let result = proto::json::ResponsePayload::new(&response)
5459                .deserialize::<DeleteSimulationApplicationResponse, _>()?;
5460
5461            Ok(result)
5462        } else {
5463            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5464            Err(DeleteSimulationApplicationError::from_response(response))
5465        }
5466    }
5467
5468    /// <p>Deregisters a robot.</p>
5469    #[allow(unused_mut)]
5470    async fn deregister_robot(
5471        &self,
5472        input: DeregisterRobotRequest,
5473    ) -> Result<DeregisterRobotResponse, RusotoError<DeregisterRobotError>> {
5474        let request_uri = "/deregisterRobot";
5475
5476        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5477        request.set_content_type("application/x-amz-json-1.1".to_owned());
5478
5479        let encoded = Some(serde_json::to_vec(&input).unwrap());
5480        request.set_payload(encoded);
5481
5482        let mut response = self
5483            .client
5484            .sign_and_dispatch(request)
5485            .await
5486            .map_err(RusotoError::from)?;
5487        if response.status.is_success() {
5488            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5489            let result = proto::json::ResponsePayload::new(&response)
5490                .deserialize::<DeregisterRobotResponse, _>()?;
5491
5492            Ok(result)
5493        } else {
5494            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5495            Err(DeregisterRobotError::from_response(response))
5496        }
5497    }
5498
5499    /// <p>Describes a deployment job.</p>
5500    #[allow(unused_mut)]
5501    async fn describe_deployment_job(
5502        &self,
5503        input: DescribeDeploymentJobRequest,
5504    ) -> Result<DescribeDeploymentJobResponse, RusotoError<DescribeDeploymentJobError>> {
5505        let request_uri = "/describeDeploymentJob";
5506
5507        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5508        request.set_content_type("application/x-amz-json-1.1".to_owned());
5509
5510        let encoded = Some(serde_json::to_vec(&input).unwrap());
5511        request.set_payload(encoded);
5512
5513        let mut response = self
5514            .client
5515            .sign_and_dispatch(request)
5516            .await
5517            .map_err(RusotoError::from)?;
5518        if response.status.is_success() {
5519            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5520            let result = proto::json::ResponsePayload::new(&response)
5521                .deserialize::<DescribeDeploymentJobResponse, _>()?;
5522
5523            Ok(result)
5524        } else {
5525            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5526            Err(DescribeDeploymentJobError::from_response(response))
5527        }
5528    }
5529
5530    /// <p>Describes a fleet.</p>
5531    #[allow(unused_mut)]
5532    async fn describe_fleet(
5533        &self,
5534        input: DescribeFleetRequest,
5535    ) -> Result<DescribeFleetResponse, RusotoError<DescribeFleetError>> {
5536        let request_uri = "/describeFleet";
5537
5538        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5539        request.set_content_type("application/x-amz-json-1.1".to_owned());
5540
5541        let encoded = Some(serde_json::to_vec(&input).unwrap());
5542        request.set_payload(encoded);
5543
5544        let mut response = self
5545            .client
5546            .sign_and_dispatch(request)
5547            .await
5548            .map_err(RusotoError::from)?;
5549        if response.status.is_success() {
5550            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5551            let result = proto::json::ResponsePayload::new(&response)
5552                .deserialize::<DescribeFleetResponse, _>()?;
5553
5554            Ok(result)
5555        } else {
5556            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5557            Err(DescribeFleetError::from_response(response))
5558        }
5559    }
5560
5561    /// <p>Describes a robot.</p>
5562    #[allow(unused_mut)]
5563    async fn describe_robot(
5564        &self,
5565        input: DescribeRobotRequest,
5566    ) -> Result<DescribeRobotResponse, RusotoError<DescribeRobotError>> {
5567        let request_uri = "/describeRobot";
5568
5569        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5570        request.set_content_type("application/x-amz-json-1.1".to_owned());
5571
5572        let encoded = Some(serde_json::to_vec(&input).unwrap());
5573        request.set_payload(encoded);
5574
5575        let mut response = self
5576            .client
5577            .sign_and_dispatch(request)
5578            .await
5579            .map_err(RusotoError::from)?;
5580        if response.status.is_success() {
5581            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5582            let result = proto::json::ResponsePayload::new(&response)
5583                .deserialize::<DescribeRobotResponse, _>()?;
5584
5585            Ok(result)
5586        } else {
5587            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5588            Err(DescribeRobotError::from_response(response))
5589        }
5590    }
5591
5592    /// <p>Describes a robot application.</p>
5593    #[allow(unused_mut)]
5594    async fn describe_robot_application(
5595        &self,
5596        input: DescribeRobotApplicationRequest,
5597    ) -> Result<DescribeRobotApplicationResponse, RusotoError<DescribeRobotApplicationError>> {
5598        let request_uri = "/describeRobotApplication";
5599
5600        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5601        request.set_content_type("application/x-amz-json-1.1".to_owned());
5602
5603        let encoded = Some(serde_json::to_vec(&input).unwrap());
5604        request.set_payload(encoded);
5605
5606        let mut response = self
5607            .client
5608            .sign_and_dispatch(request)
5609            .await
5610            .map_err(RusotoError::from)?;
5611        if response.status.is_success() {
5612            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5613            let result = proto::json::ResponsePayload::new(&response)
5614                .deserialize::<DescribeRobotApplicationResponse, _>()?;
5615
5616            Ok(result)
5617        } else {
5618            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5619            Err(DescribeRobotApplicationError::from_response(response))
5620        }
5621    }
5622
5623    /// <p>Describes a simulation application.</p>
5624    #[allow(unused_mut)]
5625    async fn describe_simulation_application(
5626        &self,
5627        input: DescribeSimulationApplicationRequest,
5628    ) -> Result<
5629        DescribeSimulationApplicationResponse,
5630        RusotoError<DescribeSimulationApplicationError>,
5631    > {
5632        let request_uri = "/describeSimulationApplication";
5633
5634        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5635        request.set_content_type("application/x-amz-json-1.1".to_owned());
5636
5637        let encoded = Some(serde_json::to_vec(&input).unwrap());
5638        request.set_payload(encoded);
5639
5640        let mut response = self
5641            .client
5642            .sign_and_dispatch(request)
5643            .await
5644            .map_err(RusotoError::from)?;
5645        if response.status.is_success() {
5646            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5647            let result = proto::json::ResponsePayload::new(&response)
5648                .deserialize::<DescribeSimulationApplicationResponse, _>()?;
5649
5650            Ok(result)
5651        } else {
5652            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5653            Err(DescribeSimulationApplicationError::from_response(response))
5654        }
5655    }
5656
5657    /// <p>Describes a simulation job.</p>
5658    #[allow(unused_mut)]
5659    async fn describe_simulation_job(
5660        &self,
5661        input: DescribeSimulationJobRequest,
5662    ) -> Result<DescribeSimulationJobResponse, RusotoError<DescribeSimulationJobError>> {
5663        let request_uri = "/describeSimulationJob";
5664
5665        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5666        request.set_content_type("application/x-amz-json-1.1".to_owned());
5667
5668        let encoded = Some(serde_json::to_vec(&input).unwrap());
5669        request.set_payload(encoded);
5670
5671        let mut response = self
5672            .client
5673            .sign_and_dispatch(request)
5674            .await
5675            .map_err(RusotoError::from)?;
5676        if response.status.is_success() {
5677            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5678            let result = proto::json::ResponsePayload::new(&response)
5679                .deserialize::<DescribeSimulationJobResponse, _>()?;
5680
5681            Ok(result)
5682        } else {
5683            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5684            Err(DescribeSimulationJobError::from_response(response))
5685        }
5686    }
5687
5688    /// <p>Describes a simulation job batch.</p>
5689    #[allow(unused_mut)]
5690    async fn describe_simulation_job_batch(
5691        &self,
5692        input: DescribeSimulationJobBatchRequest,
5693    ) -> Result<DescribeSimulationJobBatchResponse, RusotoError<DescribeSimulationJobBatchError>>
5694    {
5695        let request_uri = "/describeSimulationJobBatch";
5696
5697        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5698        request.set_content_type("application/x-amz-json-1.1".to_owned());
5699
5700        let encoded = Some(serde_json::to_vec(&input).unwrap());
5701        request.set_payload(encoded);
5702
5703        let mut response = self
5704            .client
5705            .sign_and_dispatch(request)
5706            .await
5707            .map_err(RusotoError::from)?;
5708        if response.status.is_success() {
5709            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5710            let result = proto::json::ResponsePayload::new(&response)
5711                .deserialize::<DescribeSimulationJobBatchResponse, _>()?;
5712
5713            Ok(result)
5714        } else {
5715            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5716            Err(DescribeSimulationJobBatchError::from_response(response))
5717        }
5718    }
5719
5720    /// <p>Returns a list of deployment jobs for a fleet. You can optionally provide filters to retrieve specific deployment jobs. </p>
5721    #[allow(unused_mut)]
5722    async fn list_deployment_jobs(
5723        &self,
5724        input: ListDeploymentJobsRequest,
5725    ) -> Result<ListDeploymentJobsResponse, RusotoError<ListDeploymentJobsError>> {
5726        let request_uri = "/listDeploymentJobs";
5727
5728        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5729        request.set_content_type("application/x-amz-json-1.1".to_owned());
5730
5731        let encoded = Some(serde_json::to_vec(&input).unwrap());
5732        request.set_payload(encoded);
5733
5734        let mut response = self
5735            .client
5736            .sign_and_dispatch(request)
5737            .await
5738            .map_err(RusotoError::from)?;
5739        if response.status.is_success() {
5740            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5741            let result = proto::json::ResponsePayload::new(&response)
5742                .deserialize::<ListDeploymentJobsResponse, _>()?;
5743
5744            Ok(result)
5745        } else {
5746            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5747            Err(ListDeploymentJobsError::from_response(response))
5748        }
5749    }
5750
5751    /// <p>Returns a list of fleets. You can optionally provide filters to retrieve specific fleets. </p>
5752    #[allow(unused_mut)]
5753    async fn list_fleets(
5754        &self,
5755        input: ListFleetsRequest,
5756    ) -> Result<ListFleetsResponse, RusotoError<ListFleetsError>> {
5757        let request_uri = "/listFleets";
5758
5759        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5760        request.set_content_type("application/x-amz-json-1.1".to_owned());
5761
5762        let encoded = Some(serde_json::to_vec(&input).unwrap());
5763        request.set_payload(encoded);
5764
5765        let mut response = self
5766            .client
5767            .sign_and_dispatch(request)
5768            .await
5769            .map_err(RusotoError::from)?;
5770        if response.status.is_success() {
5771            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5772            let result = proto::json::ResponsePayload::new(&response)
5773                .deserialize::<ListFleetsResponse, _>()?;
5774
5775            Ok(result)
5776        } else {
5777            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5778            Err(ListFleetsError::from_response(response))
5779        }
5780    }
5781
5782    /// <p>Returns a list of robot application. You can optionally provide filters to retrieve specific robot applications.</p>
5783    #[allow(unused_mut)]
5784    async fn list_robot_applications(
5785        &self,
5786        input: ListRobotApplicationsRequest,
5787    ) -> Result<ListRobotApplicationsResponse, RusotoError<ListRobotApplicationsError>> {
5788        let request_uri = "/listRobotApplications";
5789
5790        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5791        request.set_content_type("application/x-amz-json-1.1".to_owned());
5792
5793        let encoded = Some(serde_json::to_vec(&input).unwrap());
5794        request.set_payload(encoded);
5795
5796        let mut response = self
5797            .client
5798            .sign_and_dispatch(request)
5799            .await
5800            .map_err(RusotoError::from)?;
5801        if response.status.is_success() {
5802            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5803            let result = proto::json::ResponsePayload::new(&response)
5804                .deserialize::<ListRobotApplicationsResponse, _>()?;
5805
5806            Ok(result)
5807        } else {
5808            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5809            Err(ListRobotApplicationsError::from_response(response))
5810        }
5811    }
5812
5813    /// <p>Returns a list of robots. You can optionally provide filters to retrieve specific robots.</p>
5814    #[allow(unused_mut)]
5815    async fn list_robots(
5816        &self,
5817        input: ListRobotsRequest,
5818    ) -> Result<ListRobotsResponse, RusotoError<ListRobotsError>> {
5819        let request_uri = "/listRobots";
5820
5821        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5822        request.set_content_type("application/x-amz-json-1.1".to_owned());
5823
5824        let encoded = Some(serde_json::to_vec(&input).unwrap());
5825        request.set_payload(encoded);
5826
5827        let mut response = self
5828            .client
5829            .sign_and_dispatch(request)
5830            .await
5831            .map_err(RusotoError::from)?;
5832        if response.status.is_success() {
5833            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5834            let result = proto::json::ResponsePayload::new(&response)
5835                .deserialize::<ListRobotsResponse, _>()?;
5836
5837            Ok(result)
5838        } else {
5839            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5840            Err(ListRobotsError::from_response(response))
5841        }
5842    }
5843
5844    /// <p>Returns a list of simulation applications. You can optionally provide filters to retrieve specific simulation applications. </p>
5845    #[allow(unused_mut)]
5846    async fn list_simulation_applications(
5847        &self,
5848        input: ListSimulationApplicationsRequest,
5849    ) -> Result<ListSimulationApplicationsResponse, RusotoError<ListSimulationApplicationsError>>
5850    {
5851        let request_uri = "/listSimulationApplications";
5852
5853        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5854        request.set_content_type("application/x-amz-json-1.1".to_owned());
5855
5856        let encoded = Some(serde_json::to_vec(&input).unwrap());
5857        request.set_payload(encoded);
5858
5859        let mut response = self
5860            .client
5861            .sign_and_dispatch(request)
5862            .await
5863            .map_err(RusotoError::from)?;
5864        if response.status.is_success() {
5865            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5866            let result = proto::json::ResponsePayload::new(&response)
5867                .deserialize::<ListSimulationApplicationsResponse, _>()?;
5868
5869            Ok(result)
5870        } else {
5871            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5872            Err(ListSimulationApplicationsError::from_response(response))
5873        }
5874    }
5875
5876    /// <p>Returns a list simulation job batches. You can optionally provide filters to retrieve specific simulation batch jobs. </p>
5877    #[allow(unused_mut)]
5878    async fn list_simulation_job_batches(
5879        &self,
5880        input: ListSimulationJobBatchesRequest,
5881    ) -> Result<ListSimulationJobBatchesResponse, RusotoError<ListSimulationJobBatchesError>> {
5882        let request_uri = "/listSimulationJobBatches";
5883
5884        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5885        request.set_content_type("application/x-amz-json-1.1".to_owned());
5886
5887        let encoded = Some(serde_json::to_vec(&input).unwrap());
5888        request.set_payload(encoded);
5889
5890        let mut response = self
5891            .client
5892            .sign_and_dispatch(request)
5893            .await
5894            .map_err(RusotoError::from)?;
5895        if response.status.is_success() {
5896            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5897            let result = proto::json::ResponsePayload::new(&response)
5898                .deserialize::<ListSimulationJobBatchesResponse, _>()?;
5899
5900            Ok(result)
5901        } else {
5902            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5903            Err(ListSimulationJobBatchesError::from_response(response))
5904        }
5905    }
5906
5907    /// <p>Returns a list of simulation jobs. You can optionally provide filters to retrieve specific simulation jobs. </p>
5908    #[allow(unused_mut)]
5909    async fn list_simulation_jobs(
5910        &self,
5911        input: ListSimulationJobsRequest,
5912    ) -> Result<ListSimulationJobsResponse, RusotoError<ListSimulationJobsError>> {
5913        let request_uri = "/listSimulationJobs";
5914
5915        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5916        request.set_content_type("application/x-amz-json-1.1".to_owned());
5917
5918        let encoded = Some(serde_json::to_vec(&input).unwrap());
5919        request.set_payload(encoded);
5920
5921        let mut response = self
5922            .client
5923            .sign_and_dispatch(request)
5924            .await
5925            .map_err(RusotoError::from)?;
5926        if response.status.is_success() {
5927            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5928            let result = proto::json::ResponsePayload::new(&response)
5929                .deserialize::<ListSimulationJobsResponse, _>()?;
5930
5931            Ok(result)
5932        } else {
5933            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5934            Err(ListSimulationJobsError::from_response(response))
5935        }
5936    }
5937
5938    /// <p>Lists all tags on a AWS RoboMaker resource.</p>
5939    #[allow(unused_mut)]
5940    async fn list_tags_for_resource(
5941        &self,
5942        input: ListTagsForResourceRequest,
5943    ) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
5944        let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
5945
5946        let mut request = SignedRequest::new("GET", "robomaker", &self.region, &request_uri);
5947        request.set_content_type("application/x-amz-json-1.1".to_owned());
5948
5949        let mut response = self
5950            .client
5951            .sign_and_dispatch(request)
5952            .await
5953            .map_err(RusotoError::from)?;
5954        if response.status.is_success() {
5955            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5956            let result = proto::json::ResponsePayload::new(&response)
5957                .deserialize::<ListTagsForResourceResponse, _>()?;
5958
5959            Ok(result)
5960        } else {
5961            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5962            Err(ListTagsForResourceError::from_response(response))
5963        }
5964    }
5965
5966    /// <p>Registers a robot with a fleet.</p>
5967    #[allow(unused_mut)]
5968    async fn register_robot(
5969        &self,
5970        input: RegisterRobotRequest,
5971    ) -> Result<RegisterRobotResponse, RusotoError<RegisterRobotError>> {
5972        let request_uri = "/registerRobot";
5973
5974        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
5975        request.set_content_type("application/x-amz-json-1.1".to_owned());
5976
5977        let encoded = Some(serde_json::to_vec(&input).unwrap());
5978        request.set_payload(encoded);
5979
5980        let mut response = self
5981            .client
5982            .sign_and_dispatch(request)
5983            .await
5984            .map_err(RusotoError::from)?;
5985        if response.status.is_success() {
5986            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5987            let result = proto::json::ResponsePayload::new(&response)
5988                .deserialize::<RegisterRobotResponse, _>()?;
5989
5990            Ok(result)
5991        } else {
5992            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
5993            Err(RegisterRobotError::from_response(response))
5994        }
5995    }
5996
5997    /// <p>Restarts a running simulation job.</p>
5998    #[allow(unused_mut)]
5999    async fn restart_simulation_job(
6000        &self,
6001        input: RestartSimulationJobRequest,
6002    ) -> Result<RestartSimulationJobResponse, RusotoError<RestartSimulationJobError>> {
6003        let request_uri = "/restartSimulationJob";
6004
6005        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
6006        request.set_content_type("application/x-amz-json-1.1".to_owned());
6007
6008        let encoded = Some(serde_json::to_vec(&input).unwrap());
6009        request.set_payload(encoded);
6010
6011        let mut response = self
6012            .client
6013            .sign_and_dispatch(request)
6014            .await
6015            .map_err(RusotoError::from)?;
6016        if response.status.is_success() {
6017            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
6018            let result = proto::json::ResponsePayload::new(&response)
6019                .deserialize::<RestartSimulationJobResponse, _>()?;
6020
6021            Ok(result)
6022        } else {
6023            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
6024            Err(RestartSimulationJobError::from_response(response))
6025        }
6026    }
6027
6028    /// <p>Starts a new simulation job batch. The batch is defined using one or more <code>SimulationJobRequest</code> objects. </p>
6029    #[allow(unused_mut)]
6030    async fn start_simulation_job_batch(
6031        &self,
6032        input: StartSimulationJobBatchRequest,
6033    ) -> Result<StartSimulationJobBatchResponse, RusotoError<StartSimulationJobBatchError>> {
6034        let request_uri = "/startSimulationJobBatch";
6035
6036        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
6037        request.set_content_type("application/x-amz-json-1.1".to_owned());
6038
6039        let encoded = Some(serde_json::to_vec(&input).unwrap());
6040        request.set_payload(encoded);
6041
6042        let mut response = self
6043            .client
6044            .sign_and_dispatch(request)
6045            .await
6046            .map_err(RusotoError::from)?;
6047        if response.status.is_success() {
6048            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
6049            let result = proto::json::ResponsePayload::new(&response)
6050                .deserialize::<StartSimulationJobBatchResponse, _>()?;
6051
6052            Ok(result)
6053        } else {
6054            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
6055            Err(StartSimulationJobBatchError::from_response(response))
6056        }
6057    }
6058
6059    /// <p>Syncrhonizes robots in a fleet to the latest deployment. This is helpful if robots were added after a deployment.</p>
6060    #[allow(unused_mut)]
6061    async fn sync_deployment_job(
6062        &self,
6063        input: SyncDeploymentJobRequest,
6064    ) -> Result<SyncDeploymentJobResponse, RusotoError<SyncDeploymentJobError>> {
6065        let request_uri = "/syncDeploymentJob";
6066
6067        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
6068        request.set_content_type("application/x-amz-json-1.1".to_owned());
6069
6070        let encoded = Some(serde_json::to_vec(&input).unwrap());
6071        request.set_payload(encoded);
6072
6073        let mut response = self
6074            .client
6075            .sign_and_dispatch(request)
6076            .await
6077            .map_err(RusotoError::from)?;
6078        if response.status.is_success() {
6079            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
6080            let result = proto::json::ResponsePayload::new(&response)
6081                .deserialize::<SyncDeploymentJobResponse, _>()?;
6082
6083            Ok(result)
6084        } else {
6085            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
6086            Err(SyncDeploymentJobError::from_response(response))
6087        }
6088    }
6089
6090    /// <p>Adds or edits tags for a AWS RoboMaker resource.</p> <p>Each tag consists of a tag key and a tag value. Tag keys and tag values are both required, but tag values can be empty strings. </p> <p>For information about the rules that apply to tag keys and tag values, see <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/allocation-tag-restrictions.html">User-Defined Tag Restrictions</a> in the <i>AWS Billing and Cost Management User Guide</i>. </p>
6091    #[allow(unused_mut)]
6092    async fn tag_resource(
6093        &self,
6094        input: TagResourceRequest,
6095    ) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
6096        let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
6097
6098        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
6099        request.set_content_type("application/x-amz-json-1.1".to_owned());
6100
6101        let encoded = Some(serde_json::to_vec(&input).unwrap());
6102        request.set_payload(encoded);
6103
6104        let mut response = self
6105            .client
6106            .sign_and_dispatch(request)
6107            .await
6108            .map_err(RusotoError::from)?;
6109        if response.status.is_success() {
6110            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
6111            let result = proto::json::ResponsePayload::new(&response)
6112                .deserialize::<TagResourceResponse, _>()?;
6113
6114            Ok(result)
6115        } else {
6116            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
6117            Err(TagResourceError::from_response(response))
6118        }
6119    }
6120
6121    /// <p>Removes the specified tags from the specified AWS RoboMaker resource.</p> <p>To remove a tag, specify the tag key. To change the tag value of an existing tag key, use <a href="https://docs.aws.amazon.com/robomaker/latest/dg/API_TagResource.html"> <code>TagResource</code> </a>. </p>
6122    #[allow(unused_mut)]
6123    async fn untag_resource(
6124        &self,
6125        input: UntagResourceRequest,
6126    ) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
6127        let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
6128
6129        let mut request = SignedRequest::new("DELETE", "robomaker", &self.region, &request_uri);
6130        request.set_content_type("application/x-amz-json-1.1".to_owned());
6131
6132        let mut params = Params::new();
6133        for item in input.tag_keys.iter() {
6134            params.put("tagKeys", item);
6135        }
6136        request.set_params(params);
6137
6138        let mut response = self
6139            .client
6140            .sign_and_dispatch(request)
6141            .await
6142            .map_err(RusotoError::from)?;
6143        if response.status.is_success() {
6144            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
6145            let result = proto::json::ResponsePayload::new(&response)
6146                .deserialize::<UntagResourceResponse, _>()?;
6147
6148            Ok(result)
6149        } else {
6150            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
6151            Err(UntagResourceError::from_response(response))
6152        }
6153    }
6154
6155    /// <p>Updates a robot application.</p>
6156    #[allow(unused_mut)]
6157    async fn update_robot_application(
6158        &self,
6159        input: UpdateRobotApplicationRequest,
6160    ) -> Result<UpdateRobotApplicationResponse, RusotoError<UpdateRobotApplicationError>> {
6161        let request_uri = "/updateRobotApplication";
6162
6163        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
6164        request.set_content_type("application/x-amz-json-1.1".to_owned());
6165
6166        let encoded = Some(serde_json::to_vec(&input).unwrap());
6167        request.set_payload(encoded);
6168
6169        let mut response = self
6170            .client
6171            .sign_and_dispatch(request)
6172            .await
6173            .map_err(RusotoError::from)?;
6174        if response.status.is_success() {
6175            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
6176            let result = proto::json::ResponsePayload::new(&response)
6177                .deserialize::<UpdateRobotApplicationResponse, _>()?;
6178
6179            Ok(result)
6180        } else {
6181            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
6182            Err(UpdateRobotApplicationError::from_response(response))
6183        }
6184    }
6185
6186    /// <p>Updates a simulation application.</p>
6187    #[allow(unused_mut)]
6188    async fn update_simulation_application(
6189        &self,
6190        input: UpdateSimulationApplicationRequest,
6191    ) -> Result<UpdateSimulationApplicationResponse, RusotoError<UpdateSimulationApplicationError>>
6192    {
6193        let request_uri = "/updateSimulationApplication";
6194
6195        let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
6196        request.set_content_type("application/x-amz-json-1.1".to_owned());
6197
6198        let encoded = Some(serde_json::to_vec(&input).unwrap());
6199        request.set_payload(encoded);
6200
6201        let mut response = self
6202            .client
6203            .sign_and_dispatch(request)
6204            .await
6205            .map_err(RusotoError::from)?;
6206        if response.status.is_success() {
6207            let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
6208            let result = proto::json::ResponsePayload::new(&response)
6209                .deserialize::<UpdateSimulationApplicationResponse, _>()?;
6210
6211            Ok(result)
6212        } else {
6213            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
6214            Err(UpdateSimulationApplicationError::from_response(response))
6215        }
6216    }
6217}
rusoto_robomaker/generated.rs

rusoto_robomaker/
generated.rs
