rusoto_sms/
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::proto;
23use rusoto_core::request::HttpResponse;
24use rusoto_core::signature::SignedRequest;
25#[allow(unused_imports)]
26use serde::{Deserialize, Serialize};
27
28impl ServerMigrationServiceClient {
29    fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
30        let mut request = SignedRequest::new(http_method, "sms", &self.region, request_uri);
31
32        request.set_content_type("application/x-amz-json-1.1".to_owned());
33
34        request
35    }
36
37    async fn sign_and_dispatch<E>(
38        &self,
39        request: SignedRequest,
40        from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
41    ) -> Result<HttpResponse, RusotoError<E>> {
42        let mut response = self.client.sign_and_dispatch(request).await?;
43        if !response.status.is_success() {
44            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
45            return Err(from_response(response));
46        }
47
48        Ok(response)
49    }
50}
51
52use serde_json;
53/// <p>Information about the application.</p>
54#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
55#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
56pub struct AppSummary {
57    /// <p>The unique ID of the application.</p>
58    #[serde(rename = "appId")]
59    #[serde(skip_serializing_if = "Option::is_none")]
60    pub app_id: Option<String>,
61    /// <p>The creation time of the application.</p>
62    #[serde(rename = "creationTime")]
63    #[serde(skip_serializing_if = "Option::is_none")]
64    pub creation_time: Option<f64>,
65    /// <p>The description of the application.</p>
66    #[serde(rename = "description")]
67    #[serde(skip_serializing_if = "Option::is_none")]
68    pub description: Option<String>,
69    /// <p>The ID of the application.</p>
70    #[serde(rename = "importedAppId")]
71    #[serde(skip_serializing_if = "Option::is_none")]
72    pub imported_app_id: Option<String>,
73    /// <p>The last modified time of the application.</p>
74    #[serde(rename = "lastModified")]
75    #[serde(skip_serializing_if = "Option::is_none")]
76    pub last_modified: Option<f64>,
77    /// <p>The timestamp of the application's most recent successful replication.</p>
78    #[serde(rename = "latestReplicationTime")]
79    #[serde(skip_serializing_if = "Option::is_none")]
80    pub latest_replication_time: Option<f64>,
81    /// <p>Status of the launch configuration.</p>
82    #[serde(rename = "launchConfigurationStatus")]
83    #[serde(skip_serializing_if = "Option::is_none")]
84    pub launch_configuration_status: Option<String>,
85    /// <p>Details about the latest launch of the application.</p>
86    #[serde(rename = "launchDetails")]
87    #[serde(skip_serializing_if = "Option::is_none")]
88    pub launch_details: Option<LaunchDetails>,
89    /// <p>The launch status of the application.</p>
90    #[serde(rename = "launchStatus")]
91    #[serde(skip_serializing_if = "Option::is_none")]
92    pub launch_status: Option<String>,
93    /// <p>A message related to the launch status of the application.</p>
94    #[serde(rename = "launchStatusMessage")]
95    #[serde(skip_serializing_if = "Option::is_none")]
96    pub launch_status_message: Option<String>,
97    /// <p>The name of the application.</p>
98    #[serde(rename = "name")]
99    #[serde(skip_serializing_if = "Option::is_none")]
100    pub name: Option<String>,
101    /// <p>Status of the replication configuration.</p>
102    #[serde(rename = "replicationConfigurationStatus")]
103    #[serde(skip_serializing_if = "Option::is_none")]
104    pub replication_configuration_status: Option<String>,
105    /// <p>The replication status of the application.</p>
106    #[serde(rename = "replicationStatus")]
107    #[serde(skip_serializing_if = "Option::is_none")]
108    pub replication_status: Option<String>,
109    /// <p>A message related to the replication status of the application.</p>
110    #[serde(rename = "replicationStatusMessage")]
111    #[serde(skip_serializing_if = "Option::is_none")]
112    pub replication_status_message: Option<String>,
113    /// <p>The name of the service role in the customer's account used by AWS SMS.</p>
114    #[serde(rename = "roleName")]
115    #[serde(skip_serializing_if = "Option::is_none")]
116    pub role_name: Option<String>,
117    /// <p>Status of the application.</p>
118    #[serde(rename = "status")]
119    #[serde(skip_serializing_if = "Option::is_none")]
120    pub status: Option<String>,
121    /// <p>A message related to the status of the application</p>
122    #[serde(rename = "statusMessage")]
123    #[serde(skip_serializing_if = "Option::is_none")]
124    pub status_message: Option<String>,
125    /// <p>The number of server groups present in the application.</p>
126    #[serde(rename = "totalServerGroups")]
127    #[serde(skip_serializing_if = "Option::is_none")]
128    pub total_server_groups: Option<i64>,
129    /// <p>The number of servers present in the application.</p>
130    #[serde(rename = "totalServers")]
131    #[serde(skip_serializing_if = "Option::is_none")]
132    pub total_servers: Option<i64>,
133}
134
135/// <p>Configuration for validating an application.</p>
136#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
137pub struct AppValidationConfiguration {
138    /// <p>The validation strategy.</p>
139    #[serde(rename = "appValidationStrategy")]
140    #[serde(skip_serializing_if = "Option::is_none")]
141    pub app_validation_strategy: Option<String>,
142    /// <p>The name of the configuration.</p>
143    #[serde(rename = "name")]
144    #[serde(skip_serializing_if = "Option::is_none")]
145    pub name: Option<String>,
146    /// <p>The validation parameters.</p>
147    #[serde(rename = "ssmValidationParameters")]
148    #[serde(skip_serializing_if = "Option::is_none")]
149    pub ssm_validation_parameters: Option<SSMValidationParameters>,
150    /// <p>The ID of the validation.</p>
151    #[serde(rename = "validationId")]
152    #[serde(skip_serializing_if = "Option::is_none")]
153    pub validation_id: Option<String>,
154}
155
156/// <p>Output from validating an application.</p>
157#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
158#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
159pub struct AppValidationOutput {
160    /// <p>Output from using SSM to validate the application.</p>
161    #[serde(rename = "ssmOutput")]
162    #[serde(skip_serializing_if = "Option::is_none")]
163    pub ssm_output: Option<SSMOutput>,
164}
165
166/// <p>Represents a connector.</p>
167#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
168#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
169pub struct Connector {
170    /// <p>The time the connector was associated.</p>
171    #[serde(rename = "associatedOn")]
172    #[serde(skip_serializing_if = "Option::is_none")]
173    pub associated_on: Option<f64>,
174    /// <p>The capabilities of the connector.</p>
175    #[serde(rename = "capabilityList")]
176    #[serde(skip_serializing_if = "Option::is_none")]
177    pub capability_list: Option<Vec<String>>,
178    /// <p>The ID of the connector.</p>
179    #[serde(rename = "connectorId")]
180    #[serde(skip_serializing_if = "Option::is_none")]
181    pub connector_id: Option<String>,
182    /// <p>The IP address of the connector.</p>
183    #[serde(rename = "ipAddress")]
184    #[serde(skip_serializing_if = "Option::is_none")]
185    pub ip_address: Option<String>,
186    /// <p>The MAC address of the connector.</p>
187    #[serde(rename = "macAddress")]
188    #[serde(skip_serializing_if = "Option::is_none")]
189    pub mac_address: Option<String>,
190    /// <p>The status of the connector.</p>
191    #[serde(rename = "status")]
192    #[serde(skip_serializing_if = "Option::is_none")]
193    pub status: Option<String>,
194    /// <p>The connector version.</p>
195    #[serde(rename = "version")]
196    #[serde(skip_serializing_if = "Option::is_none")]
197    pub version: Option<String>,
198    /// <p>The ID of the VM manager.</p>
199    #[serde(rename = "vmManagerId")]
200    #[serde(skip_serializing_if = "Option::is_none")]
201    pub vm_manager_id: Option<String>,
202    /// <p>The name of the VM manager.</p>
203    #[serde(rename = "vmManagerName")]
204    #[serde(skip_serializing_if = "Option::is_none")]
205    pub vm_manager_name: Option<String>,
206    /// <p>The VM management product.</p>
207    #[serde(rename = "vmManagerType")]
208    #[serde(skip_serializing_if = "Option::is_none")]
209    pub vm_manager_type: Option<String>,
210}
211
212#[derive(Clone, Debug, Default, PartialEq, Serialize)]
213#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
214pub struct CreateAppRequest {
215    /// <p>A unique, case-sensitive identifier that you provide to ensure the idempotency of application creation.</p>
216    #[serde(rename = "clientToken")]
217    #[serde(skip_serializing_if = "Option::is_none")]
218    pub client_token: Option<String>,
219    /// <p>The description of the new application</p>
220    #[serde(rename = "description")]
221    #[serde(skip_serializing_if = "Option::is_none")]
222    pub description: Option<String>,
223    /// <p>The name of the new application.</p>
224    #[serde(rename = "name")]
225    #[serde(skip_serializing_if = "Option::is_none")]
226    pub name: Option<String>,
227    /// <p>The name of the service role in the customer's account to be used by AWS SMS.</p>
228    #[serde(rename = "roleName")]
229    #[serde(skip_serializing_if = "Option::is_none")]
230    pub role_name: Option<String>,
231    /// <p>The server groups to include in the application.</p>
232    #[serde(rename = "serverGroups")]
233    #[serde(skip_serializing_if = "Option::is_none")]
234    pub server_groups: Option<Vec<ServerGroup>>,
235    /// <p>The tags to be associated with the application.</p>
236    #[serde(rename = "tags")]
237    #[serde(skip_serializing_if = "Option::is_none")]
238    pub tags: Option<Vec<Tag>>,
239}
240
241#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
242#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
243pub struct CreateAppResponse {
244    /// <p>A summary description of the application.</p>
245    #[serde(rename = "appSummary")]
246    #[serde(skip_serializing_if = "Option::is_none")]
247    pub app_summary: Option<AppSummary>,
248    /// <p>The server groups included in the application.</p>
249    #[serde(rename = "serverGroups")]
250    #[serde(skip_serializing_if = "Option::is_none")]
251    pub server_groups: Option<Vec<ServerGroup>>,
252    /// <p>The tags associated with the application.</p>
253    #[serde(rename = "tags")]
254    #[serde(skip_serializing_if = "Option::is_none")]
255    pub tags: Option<Vec<Tag>>,
256}
257
258#[derive(Clone, Debug, Default, PartialEq, Serialize)]
259#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
260pub struct CreateReplicationJobRequest {
261    /// <p>The description of the replication job.</p>
262    #[serde(rename = "description")]
263    #[serde(skip_serializing_if = "Option::is_none")]
264    pub description: Option<String>,
265    /// <p>Indicates whether the replication job produces encrypted AMIs.</p>
266    #[serde(rename = "encrypted")]
267    #[serde(skip_serializing_if = "Option::is_none")]
268    pub encrypted: Option<bool>,
269    /// <p>The time between consecutive replication runs, in hours.</p>
270    #[serde(rename = "frequency")]
271    #[serde(skip_serializing_if = "Option::is_none")]
272    pub frequency: Option<i64>,
273    /// <p>The ID of the KMS key for replication jobs that produce encrypted AMIs. This value can be any of the following:</p> <ul> <li> <p>KMS key ID</p> </li> <li> <p>KMS key alias</p> </li> <li> <p>ARN referring to the KMS key ID</p> </li> <li> <p>ARN referring to the KMS key alias</p> </li> </ul> <p> If encrypted is <i>true</i> but a KMS key ID is not specified, the customer's default KMS key for Amazon EBS is used. </p>
274    #[serde(rename = "kmsKeyId")]
275    #[serde(skip_serializing_if = "Option::is_none")]
276    pub kms_key_id: Option<String>,
277    /// <p>The license type to be used for the AMI created by a successful replication run.</p>
278    #[serde(rename = "licenseType")]
279    #[serde(skip_serializing_if = "Option::is_none")]
280    pub license_type: Option<String>,
281    /// <p>The maximum number of SMS-created AMIs to retain. The oldest is deleted after the maximum number is reached and a new AMI is created.</p>
282    #[serde(rename = "numberOfRecentAmisToKeep")]
283    #[serde(skip_serializing_if = "Option::is_none")]
284    pub number_of_recent_amis_to_keep: Option<i64>,
285    /// <p>The name of the IAM role to be used by the AWS SMS.</p>
286    #[serde(rename = "roleName")]
287    #[serde(skip_serializing_if = "Option::is_none")]
288    pub role_name: Option<String>,
289    /// <p>Indicates whether to run the replication job one time.</p>
290    #[serde(rename = "runOnce")]
291    #[serde(skip_serializing_if = "Option::is_none")]
292    pub run_once: Option<bool>,
293    /// <p>The seed replication time.</p>
294    #[serde(rename = "seedReplicationTime")]
295    pub seed_replication_time: f64,
296    /// <p>The ID of the server.</p>
297    #[serde(rename = "serverId")]
298    pub server_id: String,
299}
300
301#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
302#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
303pub struct CreateReplicationJobResponse {
304    /// <p>The unique identifier of the replication job.</p>
305    #[serde(rename = "replicationJobId")]
306    #[serde(skip_serializing_if = "Option::is_none")]
307    pub replication_job_id: Option<String>,
308}
309
310#[derive(Clone, Debug, Default, PartialEq, Serialize)]
311#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
312pub struct DeleteAppLaunchConfigurationRequest {
313    /// <p>The ID of the application.</p>
314    #[serde(rename = "appId")]
315    #[serde(skip_serializing_if = "Option::is_none")]
316    pub app_id: Option<String>,
317}
318
319#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
320#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
321pub struct DeleteAppLaunchConfigurationResponse {}
322
323#[derive(Clone, Debug, Default, PartialEq, Serialize)]
324#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
325pub struct DeleteAppReplicationConfigurationRequest {
326    /// <p>The ID of the application.</p>
327    #[serde(rename = "appId")]
328    #[serde(skip_serializing_if = "Option::is_none")]
329    pub app_id: Option<String>,
330}
331
332#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
333#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
334pub struct DeleteAppReplicationConfigurationResponse {}
335
336#[derive(Clone, Debug, Default, PartialEq, Serialize)]
337#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
338pub struct DeleteAppRequest {
339    /// <p>The ID of the application.</p>
340    #[serde(rename = "appId")]
341    #[serde(skip_serializing_if = "Option::is_none")]
342    pub app_id: Option<String>,
343    /// <p>Indicates whether to stop all replication jobs corresponding to the servers in the application while deleting the application.</p>
344    #[serde(rename = "forceStopAppReplication")]
345    #[serde(skip_serializing_if = "Option::is_none")]
346    pub force_stop_app_replication: Option<bool>,
347    /// <p>Indicates whether to terminate the stack corresponding to the application while deleting the application.</p>
348    #[serde(rename = "forceTerminateApp")]
349    #[serde(skip_serializing_if = "Option::is_none")]
350    pub force_terminate_app: Option<bool>,
351}
352
353#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
354#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
355pub struct DeleteAppResponse {}
356
357#[derive(Clone, Debug, Default, PartialEq, Serialize)]
358#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
359pub struct DeleteAppValidationConfigurationRequest {
360    /// <p>The ID of the application.</p>
361    #[serde(rename = "appId")]
362    pub app_id: String,
363}
364
365#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
366#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
367pub struct DeleteAppValidationConfigurationResponse {}
368
369#[derive(Clone, Debug, Default, PartialEq, Serialize)]
370#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
371pub struct DeleteReplicationJobRequest {
372    /// <p>The ID of the replication job.</p>
373    #[serde(rename = "replicationJobId")]
374    pub replication_job_id: String,
375}
376
377#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
378#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
379pub struct DeleteReplicationJobResponse {}
380
381#[derive(Clone, Debug, Default, PartialEq, Serialize)]
382#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
383pub struct DeleteServerCatalogRequest {}
384
385#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
386#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
387pub struct DeleteServerCatalogResponse {}
388
389#[derive(Clone, Debug, Default, PartialEq, Serialize)]
390#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
391pub struct DisassociateConnectorRequest {
392    /// <p>The ID of the connector.</p>
393    #[serde(rename = "connectorId")]
394    pub connector_id: String,
395}
396
397#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
398#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
399pub struct DisassociateConnectorResponse {}
400
401#[derive(Clone, Debug, Default, PartialEq, Serialize)]
402#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
403pub struct GenerateChangeSetRequest {
404    /// <p>The ID of the application associated with the change set.</p>
405    #[serde(rename = "appId")]
406    #[serde(skip_serializing_if = "Option::is_none")]
407    pub app_id: Option<String>,
408    /// <p>The format for the change set.</p>
409    #[serde(rename = "changesetFormat")]
410    #[serde(skip_serializing_if = "Option::is_none")]
411    pub changeset_format: Option<String>,
412}
413
414#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
415#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
416pub struct GenerateChangeSetResponse {
417    /// <p>The location of the Amazon S3 object.</p>
418    #[serde(rename = "s3Location")]
419    #[serde(skip_serializing_if = "Option::is_none")]
420    pub s_3_location: Option<S3Location>,
421}
422
423#[derive(Clone, Debug, Default, PartialEq, Serialize)]
424#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
425pub struct GenerateTemplateRequest {
426    /// <p>The ID of the application associated with the AWS CloudFormation template.</p>
427    #[serde(rename = "appId")]
428    #[serde(skip_serializing_if = "Option::is_none")]
429    pub app_id: Option<String>,
430    /// <p>The format for generating the AWS CloudFormation template.</p>
431    #[serde(rename = "templateFormat")]
432    #[serde(skip_serializing_if = "Option::is_none")]
433    pub template_format: Option<String>,
434}
435
436#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
437#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
438pub struct GenerateTemplateResponse {
439    /// <p>The location of the Amazon S3 object.</p>
440    #[serde(rename = "s3Location")]
441    #[serde(skip_serializing_if = "Option::is_none")]
442    pub s_3_location: Option<S3Location>,
443}
444
445#[derive(Clone, Debug, Default, PartialEq, Serialize)]
446#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
447pub struct GetAppLaunchConfigurationRequest {
448    /// <p>The ID of the application.</p>
449    #[serde(rename = "appId")]
450    #[serde(skip_serializing_if = "Option::is_none")]
451    pub app_id: Option<String>,
452}
453
454#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
455#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
456pub struct GetAppLaunchConfigurationResponse {
457    /// <p>The ID of the application.</p>
458    #[serde(rename = "appId")]
459    #[serde(skip_serializing_if = "Option::is_none")]
460    pub app_id: Option<String>,
461    /// <p>Indicates whether the application is configured to launch automatically after replication is complete.</p>
462    #[serde(rename = "autoLaunch")]
463    #[serde(skip_serializing_if = "Option::is_none")]
464    pub auto_launch: Option<bool>,
465    /// <p>The name of the service role in the customer's account that AWS CloudFormation uses to launch the application.</p>
466    #[serde(rename = "roleName")]
467    #[serde(skip_serializing_if = "Option::is_none")]
468    pub role_name: Option<String>,
469    /// <p>The launch configurations for server groups in this application.</p>
470    #[serde(rename = "serverGroupLaunchConfigurations")]
471    #[serde(skip_serializing_if = "Option::is_none")]
472    pub server_group_launch_configurations: Option<Vec<ServerGroupLaunchConfiguration>>,
473}
474
475#[derive(Clone, Debug, Default, PartialEq, Serialize)]
476#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
477pub struct GetAppReplicationConfigurationRequest {
478    /// <p>The ID of the application.</p>
479    #[serde(rename = "appId")]
480    #[serde(skip_serializing_if = "Option::is_none")]
481    pub app_id: Option<String>,
482}
483
484#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
485#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
486pub struct GetAppReplicationConfigurationResponse {
487    /// <p>The replication configurations associated with server groups in this application.</p>
488    #[serde(rename = "serverGroupReplicationConfigurations")]
489    #[serde(skip_serializing_if = "Option::is_none")]
490    pub server_group_replication_configurations: Option<Vec<ServerGroupReplicationConfiguration>>,
491}
492
493#[derive(Clone, Debug, Default, PartialEq, Serialize)]
494#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
495pub struct GetAppRequest {
496    /// <p>The ID of the application.</p>
497    #[serde(rename = "appId")]
498    #[serde(skip_serializing_if = "Option::is_none")]
499    pub app_id: Option<String>,
500}
501
502#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
503#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
504pub struct GetAppResponse {
505    /// <p>Information about the application.</p>
506    #[serde(rename = "appSummary")]
507    #[serde(skip_serializing_if = "Option::is_none")]
508    pub app_summary: Option<AppSummary>,
509    /// <p>The server groups that belong to the application.</p>
510    #[serde(rename = "serverGroups")]
511    #[serde(skip_serializing_if = "Option::is_none")]
512    pub server_groups: Option<Vec<ServerGroup>>,
513    /// <p>The tags associated with the application.</p>
514    #[serde(rename = "tags")]
515    #[serde(skip_serializing_if = "Option::is_none")]
516    pub tags: Option<Vec<Tag>>,
517}
518
519#[derive(Clone, Debug, Default, PartialEq, Serialize)]
520#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
521pub struct GetAppValidationConfigurationRequest {
522    /// <p>The ID of the application.</p>
523    #[serde(rename = "appId")]
524    pub app_id: String,
525}
526
527#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
528#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
529pub struct GetAppValidationConfigurationResponse {
530    /// <p>The configuration for application validation.</p>
531    #[serde(rename = "appValidationConfigurations")]
532    #[serde(skip_serializing_if = "Option::is_none")]
533    pub app_validation_configurations: Option<Vec<AppValidationConfiguration>>,
534    /// <p>The configuration for instance validation.</p>
535    #[serde(rename = "serverGroupValidationConfigurations")]
536    #[serde(skip_serializing_if = "Option::is_none")]
537    pub server_group_validation_configurations: Option<Vec<ServerGroupValidationConfiguration>>,
538}
539
540#[derive(Clone, Debug, Default, PartialEq, Serialize)]
541#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
542pub struct GetAppValidationOutputRequest {
543    /// <p>The ID of the application.</p>
544    #[serde(rename = "appId")]
545    pub app_id: String,
546}
547
548#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
549#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
550pub struct GetAppValidationOutputResponse {
551    /// <p>The validation output.</p>
552    #[serde(rename = "validationOutputList")]
553    #[serde(skip_serializing_if = "Option::is_none")]
554    pub validation_output_list: Option<Vec<ValidationOutput>>,
555}
556
557#[derive(Clone, Debug, Default, PartialEq, Serialize)]
558#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
559pub struct GetConnectorsRequest {
560    /// <p>The maximum number of results to return in a single call. The default value is 50. To retrieve the remaining results, make another call with the returned <code>NextToken</code> value.</p>
561    #[serde(rename = "maxResults")]
562    #[serde(skip_serializing_if = "Option::is_none")]
563    pub max_results: Option<i64>,
564    /// <p>The token for the next set of results.</p>
565    #[serde(rename = "nextToken")]
566    #[serde(skip_serializing_if = "Option::is_none")]
567    pub next_token: Option<String>,
568}
569
570#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
571#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
572pub struct GetConnectorsResponse {
573    /// <p>Information about the registered connectors.</p>
574    #[serde(rename = "connectorList")]
575    #[serde(skip_serializing_if = "Option::is_none")]
576    pub connector_list: Option<Vec<Connector>>,
577    /// <p>The token required to retrieve the next set of results. This value is null when there are no more results to return.</p>
578    #[serde(rename = "nextToken")]
579    #[serde(skip_serializing_if = "Option::is_none")]
580    pub next_token: Option<String>,
581}
582
583#[derive(Clone, Debug, Default, PartialEq, Serialize)]
584#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
585pub struct GetReplicationJobsRequest {
586    /// <p>The maximum number of results to return in a single call. The default value is 50. To retrieve the remaining results, make another call with the returned <code>NextToken</code> value.</p>
587    #[serde(rename = "maxResults")]
588    #[serde(skip_serializing_if = "Option::is_none")]
589    pub max_results: Option<i64>,
590    /// <p>The token for the next set of results.</p>
591    #[serde(rename = "nextToken")]
592    #[serde(skip_serializing_if = "Option::is_none")]
593    pub next_token: Option<String>,
594    /// <p>The ID of the replication job.</p>
595    #[serde(rename = "replicationJobId")]
596    #[serde(skip_serializing_if = "Option::is_none")]
597    pub replication_job_id: Option<String>,
598}
599
600#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
601#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
602pub struct GetReplicationJobsResponse {
603    /// <p>The token required to retrieve the next set of results. This value is null when there are no more results to return.</p>
604    #[serde(rename = "nextToken")]
605    #[serde(skip_serializing_if = "Option::is_none")]
606    pub next_token: Option<String>,
607    /// <p>Information about the replication jobs.</p>
608    #[serde(rename = "replicationJobList")]
609    #[serde(skip_serializing_if = "Option::is_none")]
610    pub replication_job_list: Option<Vec<ReplicationJob>>,
611}
612
613#[derive(Clone, Debug, Default, PartialEq, Serialize)]
614#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
615pub struct GetReplicationRunsRequest {
616    /// <p>The maximum number of results to return in a single call. The default value is 50. To retrieve the remaining results, make another call with the returned <code>NextToken</code> value.</p>
617    #[serde(rename = "maxResults")]
618    #[serde(skip_serializing_if = "Option::is_none")]
619    pub max_results: Option<i64>,
620    /// <p>The token for the next set of results.</p>
621    #[serde(rename = "nextToken")]
622    #[serde(skip_serializing_if = "Option::is_none")]
623    pub next_token: Option<String>,
624    /// <p>The ID of the replication job.</p>
625    #[serde(rename = "replicationJobId")]
626    pub replication_job_id: String,
627}
628
629#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
630#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
631pub struct GetReplicationRunsResponse {
632    /// <p>The token required to retrieve the next set of results. This value is null when there are no more results to return.</p>
633    #[serde(rename = "nextToken")]
634    #[serde(skip_serializing_if = "Option::is_none")]
635    pub next_token: Option<String>,
636    /// <p>Information about the replication job.</p>
637    #[serde(rename = "replicationJob")]
638    #[serde(skip_serializing_if = "Option::is_none")]
639    pub replication_job: Option<ReplicationJob>,
640    /// <p>Information about the replication runs.</p>
641    #[serde(rename = "replicationRunList")]
642    #[serde(skip_serializing_if = "Option::is_none")]
643    pub replication_run_list: Option<Vec<ReplicationRun>>,
644}
645
646#[derive(Clone, Debug, Default, PartialEq, Serialize)]
647#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
648pub struct GetServersRequest {
649    /// <p>The maximum number of results to return in a single call. The default value is 50. To retrieve the remaining results, make another call with the returned <code>NextToken</code> value.</p>
650    #[serde(rename = "maxResults")]
651    #[serde(skip_serializing_if = "Option::is_none")]
652    pub max_results: Option<i64>,
653    /// <p>The token for the next set of results.</p>
654    #[serde(rename = "nextToken")]
655    #[serde(skip_serializing_if = "Option::is_none")]
656    pub next_token: Option<String>,
657    /// <p>The server addresses.</p>
658    #[serde(rename = "vmServerAddressList")]
659    #[serde(skip_serializing_if = "Option::is_none")]
660    pub vm_server_address_list: Option<Vec<VmServerAddress>>,
661}
662
663#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
664#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
665pub struct GetServersResponse {
666    /// <p>The time when the server was last modified.</p>
667    #[serde(rename = "lastModifiedOn")]
668    #[serde(skip_serializing_if = "Option::is_none")]
669    pub last_modified_on: Option<f64>,
670    /// <p>The token required to retrieve the next set of results. This value is null when there are no more results to return.</p>
671    #[serde(rename = "nextToken")]
672    #[serde(skip_serializing_if = "Option::is_none")]
673    pub next_token: Option<String>,
674    /// <p>The status of the server catalog.</p>
675    #[serde(rename = "serverCatalogStatus")]
676    #[serde(skip_serializing_if = "Option::is_none")]
677    pub server_catalog_status: Option<String>,
678    /// <p>Information about the servers.</p>
679    #[serde(rename = "serverList")]
680    #[serde(skip_serializing_if = "Option::is_none")]
681    pub server_list: Option<Vec<Server>>,
682}
683
684#[derive(Clone, Debug, Default, PartialEq, Serialize)]
685#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
686pub struct ImportAppCatalogRequest {
687    /// <p>The name of the service role. If you omit this parameter, we create a service-linked role for AWS Migration Hub in your account. Otherwise, the role that you provide must have the <a href="https://docs.aws.amazon.com/migrationhub/latest/ug/new-customer-setup.html#sms-managed">policy and trust policy</a> described in the <i>AWS Migration Hub User Guide</i>.</p>
688    #[serde(rename = "roleName")]
689    #[serde(skip_serializing_if = "Option::is_none")]
690    pub role_name: Option<String>,
691}
692
693#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
694#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
695pub struct ImportAppCatalogResponse {}
696
697#[derive(Clone, Debug, Default, PartialEq, Serialize)]
698#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
699pub struct ImportServerCatalogRequest {}
700
701#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
702#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
703pub struct ImportServerCatalogResponse {}
704
705#[derive(Clone, Debug, Default, PartialEq, Serialize)]
706#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
707pub struct LaunchAppRequest {
708    /// <p>The ID of the application.</p>
709    #[serde(rename = "appId")]
710    #[serde(skip_serializing_if = "Option::is_none")]
711    pub app_id: Option<String>,
712}
713
714#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
715#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
716pub struct LaunchAppResponse {}
717
718/// <p>Details about the latest launch of an application.</p>
719#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
720#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
721pub struct LaunchDetails {
722    /// <p>The latest time that this application was launched successfully.</p>
723    #[serde(rename = "latestLaunchTime")]
724    #[serde(skip_serializing_if = "Option::is_none")]
725    pub latest_launch_time: Option<f64>,
726    /// <p>The ID of the latest stack launched for this application.</p>
727    #[serde(rename = "stackId")]
728    #[serde(skip_serializing_if = "Option::is_none")]
729    pub stack_id: Option<String>,
730    /// <p>The name of the latest stack launched for this application.</p>
731    #[serde(rename = "stackName")]
732    #[serde(skip_serializing_if = "Option::is_none")]
733    pub stack_name: Option<String>,
734}
735
736#[derive(Clone, Debug, Default, PartialEq, Serialize)]
737#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
738pub struct ListAppsRequest {
739    /// <p>The unique application IDs.</p>
740    #[serde(rename = "appIds")]
741    #[serde(skip_serializing_if = "Option::is_none")]
742    pub app_ids: Option<Vec<String>>,
743    /// <p>The maximum number of results to return in a single call. The default value is 100. To retrieve the remaining results, make another call with the returned <code>NextToken</code> value. </p>
744    #[serde(rename = "maxResults")]
745    #[serde(skip_serializing_if = "Option::is_none")]
746    pub max_results: Option<i64>,
747    /// <p>The token for the next set of results.</p>
748    #[serde(rename = "nextToken")]
749    #[serde(skip_serializing_if = "Option::is_none")]
750    pub next_token: Option<String>,
751}
752
753#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
754#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
755pub struct ListAppsResponse {
756    /// <p>The application summaries.</p>
757    #[serde(rename = "apps")]
758    #[serde(skip_serializing_if = "Option::is_none")]
759    pub apps: Option<Vec<AppSummary>>,
760    /// <p>The token required to retrieve the next set of results. This value is null when there are no more results to return.</p>
761    #[serde(rename = "nextToken")]
762    #[serde(skip_serializing_if = "Option::is_none")]
763    pub next_token: Option<String>,
764}
765
766/// <p>Contains the status of validating an application.</p>
767#[derive(Clone, Debug, Default, PartialEq, Serialize)]
768#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
769pub struct NotificationContext {
770    /// <p>The status of the validation.</p>
771    #[serde(rename = "status")]
772    #[serde(skip_serializing_if = "Option::is_none")]
773    pub status: Option<String>,
774    /// <p>The status message.</p>
775    #[serde(rename = "statusMessage")]
776    #[serde(skip_serializing_if = "Option::is_none")]
777    pub status_message: Option<String>,
778    /// <p>The ID of the validation.</p>
779    #[serde(rename = "validationId")]
780    #[serde(skip_serializing_if = "Option::is_none")]
781    pub validation_id: Option<String>,
782}
783
784#[derive(Clone, Debug, Default, PartialEq, Serialize)]
785#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
786pub struct NotifyAppValidationOutputRequest {
787    /// <p>The ID of the application.</p>
788    #[serde(rename = "appId")]
789    pub app_id: String,
790    /// <p>The notification information.</p>
791    #[serde(rename = "notificationContext")]
792    #[serde(skip_serializing_if = "Option::is_none")]
793    pub notification_context: Option<NotificationContext>,
794}
795
796#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
797#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
798pub struct NotifyAppValidationOutputResponse {}
799
800#[derive(Clone, Debug, Default, PartialEq, Serialize)]
801#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
802pub struct PutAppLaunchConfigurationRequest {
803    /// <p>The ID of the application.</p>
804    #[serde(rename = "appId")]
805    #[serde(skip_serializing_if = "Option::is_none")]
806    pub app_id: Option<String>,
807    /// <p>Indicates whether the application is configured to launch automatically after replication is complete.</p>
808    #[serde(rename = "autoLaunch")]
809    #[serde(skip_serializing_if = "Option::is_none")]
810    pub auto_launch: Option<bool>,
811    /// <p>The name of service role in the customer's account that AWS CloudFormation uses to launch the application.</p>
812    #[serde(rename = "roleName")]
813    #[serde(skip_serializing_if = "Option::is_none")]
814    pub role_name: Option<String>,
815    /// <p>Information about the launch configurations for server groups in the application.</p>
816    #[serde(rename = "serverGroupLaunchConfigurations")]
817    #[serde(skip_serializing_if = "Option::is_none")]
818    pub server_group_launch_configurations: Option<Vec<ServerGroupLaunchConfiguration>>,
819}
820
821#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
822#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
823pub struct PutAppLaunchConfigurationResponse {}
824
825#[derive(Clone, Debug, Default, PartialEq, Serialize)]
826#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
827pub struct PutAppReplicationConfigurationRequest {
828    /// <p>The ID of the application.</p>
829    #[serde(rename = "appId")]
830    #[serde(skip_serializing_if = "Option::is_none")]
831    pub app_id: Option<String>,
832    /// <p>Information about the replication configurations for server groups in the application.</p>
833    #[serde(rename = "serverGroupReplicationConfigurations")]
834    #[serde(skip_serializing_if = "Option::is_none")]
835    pub server_group_replication_configurations: Option<Vec<ServerGroupReplicationConfiguration>>,
836}
837
838#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
839#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
840pub struct PutAppReplicationConfigurationResponse {}
841
842#[derive(Clone, Debug, Default, PartialEq, Serialize)]
843#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
844pub struct PutAppValidationConfigurationRequest {
845    /// <p>The ID of the application.</p>
846    #[serde(rename = "appId")]
847    pub app_id: String,
848    /// <p>The configuration for application validation.</p>
849    #[serde(rename = "appValidationConfigurations")]
850    #[serde(skip_serializing_if = "Option::is_none")]
851    pub app_validation_configurations: Option<Vec<AppValidationConfiguration>>,
852    /// <p>The configuration for instance validation.</p>
853    #[serde(rename = "serverGroupValidationConfigurations")]
854    #[serde(skip_serializing_if = "Option::is_none")]
855    pub server_group_validation_configurations: Option<Vec<ServerGroupValidationConfiguration>>,
856}
857
858#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
859#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
860pub struct PutAppValidationConfigurationResponse {}
861
862/// <p>Represents a replication job.</p>
863#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
864#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
865pub struct ReplicationJob {
866    /// <p>The description of the replication job.</p>
867    #[serde(rename = "description")]
868    #[serde(skip_serializing_if = "Option::is_none")]
869    pub description: Option<String>,
870    /// <p>Indicates whether the replication job should produce encrypted AMIs.</p>
871    #[serde(rename = "encrypted")]
872    #[serde(skip_serializing_if = "Option::is_none")]
873    pub encrypted: Option<bool>,
874    /// <p>The time between consecutive replication runs, in hours.</p>
875    #[serde(rename = "frequency")]
876    #[serde(skip_serializing_if = "Option::is_none")]
877    pub frequency: Option<i64>,
878    /// <p>The ID of the KMS key for replication jobs that produce encrypted AMIs. This value can be any of the following: </p> <ul> <li> <p>KMS key ID</p> </li> <li> <p>KMS key alias</p> </li> <li> <p>ARN referring to the KMS key ID</p> </li> <li> <p>ARN referring to the KMS key alias</p> </li> </ul> <p>If encrypted is enabled but a KMS key ID is not specified, the customer's default KMS key for Amazon EBS is used.</p>
879    #[serde(rename = "kmsKeyId")]
880    #[serde(skip_serializing_if = "Option::is_none")]
881    pub kms_key_id: Option<String>,
882    /// <p>The ID of the latest Amazon Machine Image (AMI).</p>
883    #[serde(rename = "latestAmiId")]
884    #[serde(skip_serializing_if = "Option::is_none")]
885    pub latest_ami_id: Option<String>,
886    /// <p>The license type to be used for the AMI created by a successful replication run.</p>
887    #[serde(rename = "licenseType")]
888    #[serde(skip_serializing_if = "Option::is_none")]
889    pub license_type: Option<String>,
890    /// <p>The start time of the next replication run.</p>
891    #[serde(rename = "nextReplicationRunStartTime")]
892    #[serde(skip_serializing_if = "Option::is_none")]
893    pub next_replication_run_start_time: Option<f64>,
894    /// <p>The number of recent AMIs to keep in the customer's account for a replication job. By default, the value is set to zero, meaning that all AMIs are kept.</p>
895    #[serde(rename = "numberOfRecentAmisToKeep")]
896    #[serde(skip_serializing_if = "Option::is_none")]
897    pub number_of_recent_amis_to_keep: Option<i64>,
898    /// <p>The ID of the replication job.</p>
899    #[serde(rename = "replicationJobId")]
900    #[serde(skip_serializing_if = "Option::is_none")]
901    pub replication_job_id: Option<String>,
902    /// <p>Information about the replication runs.</p>
903    #[serde(rename = "replicationRunList")]
904    #[serde(skip_serializing_if = "Option::is_none")]
905    pub replication_run_list: Option<Vec<ReplicationRun>>,
906    /// <p>The name of the IAM role to be used by AWS SMS.</p>
907    #[serde(rename = "roleName")]
908    #[serde(skip_serializing_if = "Option::is_none")]
909    pub role_name: Option<String>,
910    /// <p>Indicates whether to run the replication job one time.</p>
911    #[serde(rename = "runOnce")]
912    #[serde(skip_serializing_if = "Option::is_none")]
913    pub run_once: Option<bool>,
914    /// <p>The seed replication time.</p>
915    #[serde(rename = "seedReplicationTime")]
916    #[serde(skip_serializing_if = "Option::is_none")]
917    pub seed_replication_time: Option<f64>,
918    /// <p>The ID of the server.</p>
919    #[serde(rename = "serverId")]
920    #[serde(skip_serializing_if = "Option::is_none")]
921    pub server_id: Option<String>,
922    /// <p>The type of server.</p>
923    #[serde(rename = "serverType")]
924    #[serde(skip_serializing_if = "Option::is_none")]
925    pub server_type: Option<String>,
926    /// <p>The state of the replication job.</p>
927    #[serde(rename = "state")]
928    #[serde(skip_serializing_if = "Option::is_none")]
929    pub state: Option<String>,
930    /// <p>The description of the current status of the replication job.</p>
931    #[serde(rename = "statusMessage")]
932    #[serde(skip_serializing_if = "Option::is_none")]
933    pub status_message: Option<String>,
934    /// <p>Information about the VM server.</p>
935    #[serde(rename = "vmServer")]
936    #[serde(skip_serializing_if = "Option::is_none")]
937    pub vm_server: Option<VmServer>,
938}
939
940/// <p>Represents a replication run.</p>
941#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
942#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
943pub struct ReplicationRun {
944    /// <p>The ID of the Amazon Machine Image (AMI) from the replication run.</p>
945    #[serde(rename = "amiId")]
946    #[serde(skip_serializing_if = "Option::is_none")]
947    pub ami_id: Option<String>,
948    /// <p>The completion time of the last replication run.</p>
949    #[serde(rename = "completedTime")]
950    #[serde(skip_serializing_if = "Option::is_none")]
951    pub completed_time: Option<f64>,
952    /// <p>The description of the replication run.</p>
953    #[serde(rename = "description")]
954    #[serde(skip_serializing_if = "Option::is_none")]
955    pub description: Option<String>,
956    /// <p>Indicates whether the replication run should produce an encrypted AMI.</p>
957    #[serde(rename = "encrypted")]
958    #[serde(skip_serializing_if = "Option::is_none")]
959    pub encrypted: Option<bool>,
960    /// <p>The ID of the KMS key for replication jobs that produce encrypted AMIs. This value can be any of the following:</p> <ul> <li> <p>KMS key ID</p> </li> <li> <p>KMS key alias</p> </li> <li> <p>ARN referring to the KMS key ID</p> </li> <li> <p>ARN referring to the KMS key alias</p> </li> </ul> <p> If encrypted is <i>true</i> but a KMS key ID is not specified, the customer's default KMS key for Amazon EBS is used. </p>
961    #[serde(rename = "kmsKeyId")]
962    #[serde(skip_serializing_if = "Option::is_none")]
963    pub kms_key_id: Option<String>,
964    /// <p>The ID of the replication run.</p>
965    #[serde(rename = "replicationRunId")]
966    #[serde(skip_serializing_if = "Option::is_none")]
967    pub replication_run_id: Option<String>,
968    /// <p>The start time of the next replication run.</p>
969    #[serde(rename = "scheduledStartTime")]
970    #[serde(skip_serializing_if = "Option::is_none")]
971    pub scheduled_start_time: Option<f64>,
972    /// <p>Details about the current stage of the replication run.</p>
973    #[serde(rename = "stageDetails")]
974    #[serde(skip_serializing_if = "Option::is_none")]
975    pub stage_details: Option<ReplicationRunStageDetails>,
976    /// <p>The state of the replication run.</p>
977    #[serde(rename = "state")]
978    #[serde(skip_serializing_if = "Option::is_none")]
979    pub state: Option<String>,
980    /// <p>The description of the current status of the replication job.</p>
981    #[serde(rename = "statusMessage")]
982    #[serde(skip_serializing_if = "Option::is_none")]
983    pub status_message: Option<String>,
984    /// <p>The type of replication run.</p>
985    #[serde(rename = "type")]
986    #[serde(skip_serializing_if = "Option::is_none")]
987    pub type_: Option<String>,
988}
989
990/// <p>Details of the current stage of a replication run.</p>
991#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
992#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
993pub struct ReplicationRunStageDetails {
994    /// <p>The current stage of a replication run.</p>
995    #[serde(rename = "stage")]
996    #[serde(skip_serializing_if = "Option::is_none")]
997    pub stage: Option<String>,
998    /// <p>The progress of the current stage of a replication run.</p>
999    #[serde(rename = "stageProgress")]
1000    #[serde(skip_serializing_if = "Option::is_none")]
1001    pub stage_progress: Option<String>,
1002}
1003
1004/// <p>Location of an Amazon S3 object.</p>
1005#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1006pub struct S3Location {
1007    /// <p>The Amazon S3 bucket name.</p>
1008    #[serde(rename = "bucket")]
1009    #[serde(skip_serializing_if = "Option::is_none")]
1010    pub bucket: Option<String>,
1011    /// <p>The Amazon S3 bucket key.</p>
1012    #[serde(rename = "key")]
1013    #[serde(skip_serializing_if = "Option::is_none")]
1014    pub key: Option<String>,
1015}
1016
1017/// <p>Contains the location of validation output.</p>
1018#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1019#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1020pub struct SSMOutput {
1021    #[serde(rename = "s3Location")]
1022    #[serde(skip_serializing_if = "Option::is_none")]
1023    pub s_3_location: Option<S3Location>,
1024}
1025
1026/// <p>Contains validation parameters.</p>
1027#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1028pub struct SSMValidationParameters {
1029    /// <p>The command to run the validation script</p>
1030    #[serde(rename = "command")]
1031    #[serde(skip_serializing_if = "Option::is_none")]
1032    pub command: Option<String>,
1033    /// <p>The timeout interval, in seconds.</p>
1034    #[serde(rename = "executionTimeoutSeconds")]
1035    #[serde(skip_serializing_if = "Option::is_none")]
1036    pub execution_timeout_seconds: Option<i64>,
1037    /// <p>The ID of the instance. The instance must have the following tag: UserForSMSApplicationValidation=true.</p>
1038    #[serde(rename = "instanceId")]
1039    #[serde(skip_serializing_if = "Option::is_none")]
1040    pub instance_id: Option<String>,
1041    /// <p>The name of the S3 bucket for output.</p>
1042    #[serde(rename = "outputS3BucketName")]
1043    #[serde(skip_serializing_if = "Option::is_none")]
1044    pub output_s3_bucket_name: Option<String>,
1045    /// <p>The type of validation script.</p>
1046    #[serde(rename = "scriptType")]
1047    #[serde(skip_serializing_if = "Option::is_none")]
1048    pub script_type: Option<String>,
1049    /// <p>The location of the validation script.</p>
1050    #[serde(rename = "source")]
1051    #[serde(skip_serializing_if = "Option::is_none")]
1052    pub source: Option<Source>,
1053}
1054
1055/// <p>Represents a server.</p>
1056#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1057pub struct Server {
1058    /// <p>The ID of the replication job.</p>
1059    #[serde(rename = "replicationJobId")]
1060    #[serde(skip_serializing_if = "Option::is_none")]
1061    pub replication_job_id: Option<String>,
1062    /// <p>Indicates whether the replication job is deleted or failed.</p>
1063    #[serde(rename = "replicationJobTerminated")]
1064    #[serde(skip_serializing_if = "Option::is_none")]
1065    pub replication_job_terminated: Option<bool>,
1066    /// <p>The ID of the server.</p>
1067    #[serde(rename = "serverId")]
1068    #[serde(skip_serializing_if = "Option::is_none")]
1069    pub server_id: Option<String>,
1070    /// <p>The type of server.</p>
1071    #[serde(rename = "serverType")]
1072    #[serde(skip_serializing_if = "Option::is_none")]
1073    pub server_type: Option<String>,
1074    /// <p>Information about the VM server.</p>
1075    #[serde(rename = "vmServer")]
1076    #[serde(skip_serializing_if = "Option::is_none")]
1077    pub vm_server: Option<VmServer>,
1078}
1079
1080/// <p>Logical grouping of servers.</p>
1081#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1082pub struct ServerGroup {
1083    /// <p>The name of a server group.</p>
1084    #[serde(rename = "name")]
1085    #[serde(skip_serializing_if = "Option::is_none")]
1086    pub name: Option<String>,
1087    /// <p>The ID of a server group.</p>
1088    #[serde(rename = "serverGroupId")]
1089    #[serde(skip_serializing_if = "Option::is_none")]
1090    pub server_group_id: Option<String>,
1091    /// <p>The servers that belong to a server group.</p>
1092    #[serde(rename = "serverList")]
1093    #[serde(skip_serializing_if = "Option::is_none")]
1094    pub server_list: Option<Vec<Server>>,
1095}
1096
1097/// <p>Launch configuration for a server group.</p>
1098#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1099pub struct ServerGroupLaunchConfiguration {
1100    /// <p>The launch order of servers in the server group.</p>
1101    #[serde(rename = "launchOrder")]
1102    #[serde(skip_serializing_if = "Option::is_none")]
1103    pub launch_order: Option<i64>,
1104    /// <p>The ID of the server group with which the launch configuration is associated.</p>
1105    #[serde(rename = "serverGroupId")]
1106    #[serde(skip_serializing_if = "Option::is_none")]
1107    pub server_group_id: Option<String>,
1108    /// <p>The launch configuration for servers in the server group.</p>
1109    #[serde(rename = "serverLaunchConfigurations")]
1110    #[serde(skip_serializing_if = "Option::is_none")]
1111    pub server_launch_configurations: Option<Vec<ServerLaunchConfiguration>>,
1112}
1113
1114/// <p>Replication configuration for a server group.</p>
1115#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1116pub struct ServerGroupReplicationConfiguration {
1117    /// <p>The ID of the server group with which this replication configuration is associated.</p>
1118    #[serde(rename = "serverGroupId")]
1119    #[serde(skip_serializing_if = "Option::is_none")]
1120    pub server_group_id: Option<String>,
1121    /// <p>The replication configuration for servers in the server group.</p>
1122    #[serde(rename = "serverReplicationConfigurations")]
1123    #[serde(skip_serializing_if = "Option::is_none")]
1124    pub server_replication_configurations: Option<Vec<ServerReplicationConfiguration>>,
1125}
1126
1127/// <p>Configuration for validating an instance.</p>
1128#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1129pub struct ServerGroupValidationConfiguration {
1130    /// <p>The ID of the server group.</p>
1131    #[serde(rename = "serverGroupId")]
1132    #[serde(skip_serializing_if = "Option::is_none")]
1133    pub server_group_id: Option<String>,
1134    /// <p>The validation configuration.</p>
1135    #[serde(rename = "serverValidationConfigurations")]
1136    #[serde(skip_serializing_if = "Option::is_none")]
1137    pub server_validation_configurations: Option<Vec<ServerValidationConfiguration>>,
1138}
1139
1140/// <p>Launch configuration for a server.</p>
1141#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1142pub struct ServerLaunchConfiguration {
1143    /// <p>Indicates whether a publicly accessible IP address is created when launching the server.</p>
1144    #[serde(rename = "associatePublicIpAddress")]
1145    #[serde(skip_serializing_if = "Option::is_none")]
1146    pub associate_public_ip_address: Option<bool>,
1147    #[serde(rename = "configureScript")]
1148    #[serde(skip_serializing_if = "Option::is_none")]
1149    pub configure_script: Option<S3Location>,
1150    /// <p>The type of configuration script.</p>
1151    #[serde(rename = "configureScriptType")]
1152    #[serde(skip_serializing_if = "Option::is_none")]
1153    pub configure_script_type: Option<String>,
1154    /// <p>The name of the Amazon EC2 SSH key to be used for connecting to the launched server.</p>
1155    #[serde(rename = "ec2KeyName")]
1156    #[serde(skip_serializing_if = "Option::is_none")]
1157    pub ec_2_key_name: Option<String>,
1158    /// <p>The name of the IAM instance profile.</p>
1159    #[serde(rename = "iamInstanceProfileName")]
1160    #[serde(skip_serializing_if = "Option::is_none")]
1161    pub iam_instance_profile_name: Option<String>,
1162    /// <p>The instance type to use when launching the server.</p>
1163    #[serde(rename = "instanceType")]
1164    #[serde(skip_serializing_if = "Option::is_none")]
1165    pub instance_type: Option<String>,
1166    /// <p>The logical ID of the server in the AWS CloudFormation template.</p>
1167    #[serde(rename = "logicalId")]
1168    #[serde(skip_serializing_if = "Option::is_none")]
1169    pub logical_id: Option<String>,
1170    /// <p>The ID of the security group that applies to the launched server.</p>
1171    #[serde(rename = "securityGroup")]
1172    #[serde(skip_serializing_if = "Option::is_none")]
1173    pub security_group: Option<String>,
1174    /// <p>The ID of the server with which the launch configuration is associated.</p>
1175    #[serde(rename = "server")]
1176    #[serde(skip_serializing_if = "Option::is_none")]
1177    pub server: Option<Server>,
1178    /// <p>The ID of the subnet the server should be launched into.</p>
1179    #[serde(rename = "subnet")]
1180    #[serde(skip_serializing_if = "Option::is_none")]
1181    pub subnet: Option<String>,
1182    /// <p>Location of the user-data script to be executed when launching the server.</p>
1183    #[serde(rename = "userData")]
1184    #[serde(skip_serializing_if = "Option::is_none")]
1185    pub user_data: Option<UserData>,
1186    /// <p>The ID of the VPC into which the server should be launched.</p>
1187    #[serde(rename = "vpc")]
1188    #[serde(skip_serializing_if = "Option::is_none")]
1189    pub vpc: Option<String>,
1190}
1191
1192/// <p>Replication configuration of a server.</p>
1193#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1194pub struct ServerReplicationConfiguration {
1195    /// <p>The ID of the server with which this replication configuration is associated.</p>
1196    #[serde(rename = "server")]
1197    #[serde(skip_serializing_if = "Option::is_none")]
1198    pub server: Option<Server>,
1199    /// <p>The parameters for replicating the server.</p>
1200    #[serde(rename = "serverReplicationParameters")]
1201    #[serde(skip_serializing_if = "Option::is_none")]
1202    pub server_replication_parameters: Option<ServerReplicationParameters>,
1203}
1204
1205/// <p>The replication parameters for replicating a server.</p>
1206#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1207pub struct ServerReplicationParameters {
1208    /// <p>Indicates whether the replication job produces encrypted AMIs.</p>
1209    #[serde(rename = "encrypted")]
1210    #[serde(skip_serializing_if = "Option::is_none")]
1211    pub encrypted: Option<bool>,
1212    /// <p>The frequency of creating replication jobs for the server.</p>
1213    #[serde(rename = "frequency")]
1214    #[serde(skip_serializing_if = "Option::is_none")]
1215    pub frequency: Option<i64>,
1216    /// <p>The ID of the KMS key for replication jobs that produce encrypted AMIs. This value can be any of the following:</p> <ul> <li> <p>KMS key ID</p> </li> <li> <p>KMS key alias</p> </li> <li> <p>ARN referring to the KMS key ID</p> </li> <li> <p>ARN referring to the KMS key alias</p> </li> </ul> <p>If encrypted is enabled but a KMS key ID is not specified, the customer's default KMS key for Amazon EBS is used.</p>
1217    #[serde(rename = "kmsKeyId")]
1218    #[serde(skip_serializing_if = "Option::is_none")]
1219    pub kms_key_id: Option<String>,
1220    /// <p>The license type for creating a replication job for the server.</p>
1221    #[serde(rename = "licenseType")]
1222    #[serde(skip_serializing_if = "Option::is_none")]
1223    pub license_type: Option<String>,
1224    /// <p>The number of recent AMIs to keep when creating a replication job for this server.</p>
1225    #[serde(rename = "numberOfRecentAmisToKeep")]
1226    #[serde(skip_serializing_if = "Option::is_none")]
1227    pub number_of_recent_amis_to_keep: Option<i64>,
1228    /// <p>Indicates whether to run the replication job one time.</p>
1229    #[serde(rename = "runOnce")]
1230    #[serde(skip_serializing_if = "Option::is_none")]
1231    pub run_once: Option<bool>,
1232    /// <p>The seed time for creating a replication job for the server.</p>
1233    #[serde(rename = "seedTime")]
1234    #[serde(skip_serializing_if = "Option::is_none")]
1235    pub seed_time: Option<f64>,
1236}
1237
1238/// <p>Configuration for validating an instance.</p>
1239#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1240pub struct ServerValidationConfiguration {
1241    /// <p>The name of the configuration.</p>
1242    #[serde(rename = "name")]
1243    #[serde(skip_serializing_if = "Option::is_none")]
1244    pub name: Option<String>,
1245    #[serde(rename = "server")]
1246    #[serde(skip_serializing_if = "Option::is_none")]
1247    pub server: Option<Server>,
1248    /// <p>The validation strategy.</p>
1249    #[serde(rename = "serverValidationStrategy")]
1250    #[serde(skip_serializing_if = "Option::is_none")]
1251    pub server_validation_strategy: Option<String>,
1252    /// <p>The validation parameters.</p>
1253    #[serde(rename = "userDataValidationParameters")]
1254    #[serde(skip_serializing_if = "Option::is_none")]
1255    pub user_data_validation_parameters: Option<UserDataValidationParameters>,
1256    /// <p>The ID of the validation.</p>
1257    #[serde(rename = "validationId")]
1258    #[serde(skip_serializing_if = "Option::is_none")]
1259    pub validation_id: Option<String>,
1260}
1261
1262/// <p>Contains output from validating an instance.</p>
1263#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1264#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1265pub struct ServerValidationOutput {
1266    #[serde(rename = "server")]
1267    #[serde(skip_serializing_if = "Option::is_none")]
1268    pub server: Option<Server>,
1269}
1270
1271/// <p>Contains the location of a validation script.</p>
1272#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1273pub struct Source {
1274    #[serde(rename = "s3Location")]
1275    #[serde(skip_serializing_if = "Option::is_none")]
1276    pub s_3_location: Option<S3Location>,
1277}
1278
1279#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1280#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1281pub struct StartAppReplicationRequest {
1282    /// <p>The ID of the application.</p>
1283    #[serde(rename = "appId")]
1284    #[serde(skip_serializing_if = "Option::is_none")]
1285    pub app_id: Option<String>,
1286}
1287
1288#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1289#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1290pub struct StartAppReplicationResponse {}
1291
1292#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1293#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1294pub struct StartOnDemandAppReplicationRequest {
1295    /// <p>The ID of the application.</p>
1296    #[serde(rename = "appId")]
1297    pub app_id: String,
1298    /// <p>The description of the replication run.</p>
1299    #[serde(rename = "description")]
1300    #[serde(skip_serializing_if = "Option::is_none")]
1301    pub description: Option<String>,
1302}
1303
1304#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1305#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1306pub struct StartOnDemandAppReplicationResponse {}
1307
1308#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1309#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1310pub struct StartOnDemandReplicationRunRequest {
1311    /// <p>The description of the replication run.</p>
1312    #[serde(rename = "description")]
1313    #[serde(skip_serializing_if = "Option::is_none")]
1314    pub description: Option<String>,
1315    /// <p>The ID of the replication job.</p>
1316    #[serde(rename = "replicationJobId")]
1317    pub replication_job_id: String,
1318}
1319
1320#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1321#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1322pub struct StartOnDemandReplicationRunResponse {
1323    /// <p>The ID of the replication run.</p>
1324    #[serde(rename = "replicationRunId")]
1325    #[serde(skip_serializing_if = "Option::is_none")]
1326    pub replication_run_id: Option<String>,
1327}
1328
1329#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1330#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1331pub struct StopAppReplicationRequest {
1332    /// <p>The ID of the application.</p>
1333    #[serde(rename = "appId")]
1334    #[serde(skip_serializing_if = "Option::is_none")]
1335    pub app_id: Option<String>,
1336}
1337
1338#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1339#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1340pub struct StopAppReplicationResponse {}
1341
1342/// <p>Key/value pair that can be assigned to an application.</p>
1343#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1344pub struct Tag {
1345    /// <p>The tag key.</p>
1346    #[serde(rename = "key")]
1347    #[serde(skip_serializing_if = "Option::is_none")]
1348    pub key: Option<String>,
1349    /// <p>The tag value.</p>
1350    #[serde(rename = "value")]
1351    #[serde(skip_serializing_if = "Option::is_none")]
1352    pub value: Option<String>,
1353}
1354
1355#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1356#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1357pub struct TerminateAppRequest {
1358    /// <p>The ID of the application.</p>
1359    #[serde(rename = "appId")]
1360    #[serde(skip_serializing_if = "Option::is_none")]
1361    pub app_id: Option<String>,
1362}
1363
1364#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1365#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1366pub struct TerminateAppResponse {}
1367
1368#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1369#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1370pub struct UpdateAppRequest {
1371    /// <p>The ID of the application.</p>
1372    #[serde(rename = "appId")]
1373    #[serde(skip_serializing_if = "Option::is_none")]
1374    pub app_id: Option<String>,
1375    /// <p>The new description of the application.</p>
1376    #[serde(rename = "description")]
1377    #[serde(skip_serializing_if = "Option::is_none")]
1378    pub description: Option<String>,
1379    /// <p>The new name of the application.</p>
1380    #[serde(rename = "name")]
1381    #[serde(skip_serializing_if = "Option::is_none")]
1382    pub name: Option<String>,
1383    /// <p>The name of the service role in the customer's account used by AWS SMS.</p>
1384    #[serde(rename = "roleName")]
1385    #[serde(skip_serializing_if = "Option::is_none")]
1386    pub role_name: Option<String>,
1387    /// <p>The server groups in the application to update.</p>
1388    #[serde(rename = "serverGroups")]
1389    #[serde(skip_serializing_if = "Option::is_none")]
1390    pub server_groups: Option<Vec<ServerGroup>>,
1391    /// <p>The tags to associate with the application.</p>
1392    #[serde(rename = "tags")]
1393    #[serde(skip_serializing_if = "Option::is_none")]
1394    pub tags: Option<Vec<Tag>>,
1395}
1396
1397#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1398#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1399pub struct UpdateAppResponse {
1400    /// <p>A summary description of the application.</p>
1401    #[serde(rename = "appSummary")]
1402    #[serde(skip_serializing_if = "Option::is_none")]
1403    pub app_summary: Option<AppSummary>,
1404    /// <p>The updated server groups in the application.</p>
1405    #[serde(rename = "serverGroups")]
1406    #[serde(skip_serializing_if = "Option::is_none")]
1407    pub server_groups: Option<Vec<ServerGroup>>,
1408    /// <p>The tags associated with the application.</p>
1409    #[serde(rename = "tags")]
1410    #[serde(skip_serializing_if = "Option::is_none")]
1411    pub tags: Option<Vec<Tag>>,
1412}
1413
1414#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1415#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1416pub struct UpdateReplicationJobRequest {
1417    /// <p>The description of the replication job.</p>
1418    #[serde(rename = "description")]
1419    #[serde(skip_serializing_if = "Option::is_none")]
1420    pub description: Option<String>,
1421    /// <p>When true, the replication job produces encrypted AMIs. For more information, <code>KmsKeyId</code>.</p>
1422    #[serde(rename = "encrypted")]
1423    #[serde(skip_serializing_if = "Option::is_none")]
1424    pub encrypted: Option<bool>,
1425    /// <p>The time between consecutive replication runs, in hours.</p>
1426    #[serde(rename = "frequency")]
1427    #[serde(skip_serializing_if = "Option::is_none")]
1428    pub frequency: Option<i64>,
1429    /// <p>The ID of the KMS key for replication jobs that produce encrypted AMIs. This value can be any of the following:</p> <ul> <li> <p>KMS key ID</p> </li> <li> <p>KMS key alias</p> </li> <li> <p>ARN referring to the KMS key ID</p> </li> <li> <p>ARN referring to the KMS key alias</p> </li> </ul> <p>If encrypted is enabled but a KMS key ID is not specified, the customer's default KMS key for Amazon EBS is used.</p>
1430    #[serde(rename = "kmsKeyId")]
1431    #[serde(skip_serializing_if = "Option::is_none")]
1432    pub kms_key_id: Option<String>,
1433    /// <p>The license type to be used for the AMI created by a successful replication run.</p>
1434    #[serde(rename = "licenseType")]
1435    #[serde(skip_serializing_if = "Option::is_none")]
1436    pub license_type: Option<String>,
1437    /// <p>The start time of the next replication run.</p>
1438    #[serde(rename = "nextReplicationRunStartTime")]
1439    #[serde(skip_serializing_if = "Option::is_none")]
1440    pub next_replication_run_start_time: Option<f64>,
1441    /// <p>The maximum number of SMS-created AMIs to retain. The oldest is deleted after the maximum number is reached and a new AMI is created.</p>
1442    #[serde(rename = "numberOfRecentAmisToKeep")]
1443    #[serde(skip_serializing_if = "Option::is_none")]
1444    pub number_of_recent_amis_to_keep: Option<i64>,
1445    /// <p>The ID of the replication job.</p>
1446    #[serde(rename = "replicationJobId")]
1447    pub replication_job_id: String,
1448    /// <p>The name of the IAM role to be used by AWS SMS.</p>
1449    #[serde(rename = "roleName")]
1450    #[serde(skip_serializing_if = "Option::is_none")]
1451    pub role_name: Option<String>,
1452}
1453
1454#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1455#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1456pub struct UpdateReplicationJobResponse {}
1457
1458/// <p>A script that runs on first launch of an Amazon EC2 instance. Used for configuring the server during launch.</p>
1459#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1460pub struct UserData {
1461    /// <p>Amazon S3 location of the user-data script.</p>
1462    #[serde(rename = "s3Location")]
1463    #[serde(skip_serializing_if = "Option::is_none")]
1464    pub s_3_location: Option<S3Location>,
1465}
1466
1467/// <p>Contains validation parameters.</p>
1468#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1469pub struct UserDataValidationParameters {
1470    /// <p>The type of validation script.</p>
1471    #[serde(rename = "scriptType")]
1472    #[serde(skip_serializing_if = "Option::is_none")]
1473    pub script_type: Option<String>,
1474    /// <p>The location of the validation script.</p>
1475    #[serde(rename = "source")]
1476    #[serde(skip_serializing_if = "Option::is_none")]
1477    pub source: Option<Source>,
1478}
1479
1480/// <p>Contains validation output.</p>
1481#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1482#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1483pub struct ValidationOutput {
1484    /// <p>The output from validating an application.</p>
1485    #[serde(rename = "appValidationOutput")]
1486    #[serde(skip_serializing_if = "Option::is_none")]
1487    pub app_validation_output: Option<AppValidationOutput>,
1488    /// <p>The latest time that the validation was performed.</p>
1489    #[serde(rename = "latestValidationTime")]
1490    #[serde(skip_serializing_if = "Option::is_none")]
1491    pub latest_validation_time: Option<f64>,
1492    /// <p>The name of the validation.</p>
1493    #[serde(rename = "name")]
1494    #[serde(skip_serializing_if = "Option::is_none")]
1495    pub name: Option<String>,
1496    /// <p>The output from validation an instance.</p>
1497    #[serde(rename = "serverValidationOutput")]
1498    #[serde(skip_serializing_if = "Option::is_none")]
1499    pub server_validation_output: Option<ServerValidationOutput>,
1500    /// <p>The status of the validation.</p>
1501    #[serde(rename = "status")]
1502    #[serde(skip_serializing_if = "Option::is_none")]
1503    pub status: Option<String>,
1504    /// <p>The status message.</p>
1505    #[serde(rename = "statusMessage")]
1506    #[serde(skip_serializing_if = "Option::is_none")]
1507    pub status_message: Option<String>,
1508    /// <p>The ID of the validation.</p>
1509    #[serde(rename = "validationId")]
1510    #[serde(skip_serializing_if = "Option::is_none")]
1511    pub validation_id: Option<String>,
1512}
1513
1514/// <p>Represents a VM server.</p>
1515#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1516pub struct VmServer {
1517    /// <p>The name of the VM manager.</p>
1518    #[serde(rename = "vmManagerName")]
1519    #[serde(skip_serializing_if = "Option::is_none")]
1520    pub vm_manager_name: Option<String>,
1521    /// <p>The type of VM management product.</p>
1522    #[serde(rename = "vmManagerType")]
1523    #[serde(skip_serializing_if = "Option::is_none")]
1524    pub vm_manager_type: Option<String>,
1525    /// <p>The name of the VM.</p>
1526    #[serde(rename = "vmName")]
1527    #[serde(skip_serializing_if = "Option::is_none")]
1528    pub vm_name: Option<String>,
1529    /// <p>The VM folder path in the vCenter Server virtual machine inventory tree.</p>
1530    #[serde(rename = "vmPath")]
1531    #[serde(skip_serializing_if = "Option::is_none")]
1532    pub vm_path: Option<String>,
1533    /// <p>The VM server location.</p>
1534    #[serde(rename = "vmServerAddress")]
1535    #[serde(skip_serializing_if = "Option::is_none")]
1536    pub vm_server_address: Option<VmServerAddress>,
1537}
1538
1539/// <p>Represents a VM server location.</p>
1540#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1541pub struct VmServerAddress {
1542    /// <p>The ID of the VM.</p>
1543    #[serde(rename = "vmId")]
1544    #[serde(skip_serializing_if = "Option::is_none")]
1545    pub vm_id: Option<String>,
1546    /// <p>The ID of the VM manager.</p>
1547    #[serde(rename = "vmManagerId")]
1548    #[serde(skip_serializing_if = "Option::is_none")]
1549    pub vm_manager_id: Option<String>,
1550}
1551
1552/// Errors returned by CreateApp
1553#[derive(Debug, PartialEq)]
1554pub enum CreateAppError {
1555    /// <p>An internal error occurred.</p>
1556    InternalError(String),
1557    /// <p>A specified parameter is not valid.</p>
1558    InvalidParameter(String),
1559    /// <p>A required parameter is missing.</p>
1560    MissingRequiredParameter(String),
1561    /// <p>This operation is not allowed.</p>
1562    OperationNotPermitted(String),
1563    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
1564    UnauthorizedOperation(String),
1565}
1566
1567impl CreateAppError {
1568    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateAppError> {
1569        if let Some(err) = proto::json::Error::parse(&res) {
1570            match err.typ.as_str() {
1571                "InternalError" => {
1572                    return RusotoError::Service(CreateAppError::InternalError(err.msg))
1573                }
1574                "InvalidParameterException" => {
1575                    return RusotoError::Service(CreateAppError::InvalidParameter(err.msg))
1576                }
1577                "MissingRequiredParameterException" => {
1578                    return RusotoError::Service(CreateAppError::MissingRequiredParameter(err.msg))
1579                }
1580                "OperationNotPermittedException" => {
1581                    return RusotoError::Service(CreateAppError::OperationNotPermitted(err.msg))
1582                }
1583                "UnauthorizedOperationException" => {
1584                    return RusotoError::Service(CreateAppError::UnauthorizedOperation(err.msg))
1585                }
1586                "ValidationException" => return RusotoError::Validation(err.msg),
1587                _ => {}
1588            }
1589        }
1590        RusotoError::Unknown(res)
1591    }
1592}
1593impl fmt::Display for CreateAppError {
1594    #[allow(unused_variables)]
1595    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1596        match *self {
1597            CreateAppError::InternalError(ref cause) => write!(f, "{}", cause),
1598            CreateAppError::InvalidParameter(ref cause) => write!(f, "{}", cause),
1599            CreateAppError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
1600            CreateAppError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
1601            CreateAppError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
1602        }
1603    }
1604}
1605impl Error for CreateAppError {}
1606/// Errors returned by CreateReplicationJob
1607#[derive(Debug, PartialEq)]
1608pub enum CreateReplicationJobError {
1609    /// <p>An internal error occurred.</p>
1610    InternalError(String),
1611    /// <p>A specified parameter is not valid.</p>
1612    InvalidParameter(String),
1613    /// <p>A required parameter is missing.</p>
1614    MissingRequiredParameter(String),
1615    /// <p>There are no connectors available.</p>
1616    NoConnectorsAvailable(String),
1617    /// <p>This operation is not allowed.</p>
1618    OperationNotPermitted(String),
1619    /// <p>The specified replication job already exists.</p>
1620    ReplicationJobAlreadyExists(String),
1621    /// <p>The specified server cannot be replicated.</p>
1622    ServerCannotBeReplicated(String),
1623    /// <p>The service is temporarily unavailable.</p>
1624    TemporarilyUnavailable(String),
1625    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
1626    UnauthorizedOperation(String),
1627}
1628
1629impl CreateReplicationJobError {
1630    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateReplicationJobError> {
1631        if let Some(err) = proto::json::Error::parse(&res) {
1632            match err.typ.as_str() {
1633                "InternalError" => {
1634                    return RusotoError::Service(CreateReplicationJobError::InternalError(err.msg))
1635                }
1636                "InvalidParameterException" => {
1637                    return RusotoError::Service(CreateReplicationJobError::InvalidParameter(
1638                        err.msg,
1639                    ))
1640                }
1641                "MissingRequiredParameterException" => {
1642                    return RusotoError::Service(
1643                        CreateReplicationJobError::MissingRequiredParameter(err.msg),
1644                    )
1645                }
1646                "NoConnectorsAvailableException" => {
1647                    return RusotoError::Service(CreateReplicationJobError::NoConnectorsAvailable(
1648                        err.msg,
1649                    ))
1650                }
1651                "OperationNotPermittedException" => {
1652                    return RusotoError::Service(CreateReplicationJobError::OperationNotPermitted(
1653                        err.msg,
1654                    ))
1655                }
1656                "ReplicationJobAlreadyExistsException" => {
1657                    return RusotoError::Service(
1658                        CreateReplicationJobError::ReplicationJobAlreadyExists(err.msg),
1659                    )
1660                }
1661                "ServerCannotBeReplicatedException" => {
1662                    return RusotoError::Service(
1663                        CreateReplicationJobError::ServerCannotBeReplicated(err.msg),
1664                    )
1665                }
1666                "TemporarilyUnavailableException" => {
1667                    return RusotoError::Service(CreateReplicationJobError::TemporarilyUnavailable(
1668                        err.msg,
1669                    ))
1670                }
1671                "UnauthorizedOperationException" => {
1672                    return RusotoError::Service(CreateReplicationJobError::UnauthorizedOperation(
1673                        err.msg,
1674                    ))
1675                }
1676                "ValidationException" => return RusotoError::Validation(err.msg),
1677                _ => {}
1678            }
1679        }
1680        RusotoError::Unknown(res)
1681    }
1682}
1683impl fmt::Display for CreateReplicationJobError {
1684    #[allow(unused_variables)]
1685    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1686        match *self {
1687            CreateReplicationJobError::InternalError(ref cause) => write!(f, "{}", cause),
1688            CreateReplicationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
1689            CreateReplicationJobError::MissingRequiredParameter(ref cause) => {
1690                write!(f, "{}", cause)
1691            }
1692            CreateReplicationJobError::NoConnectorsAvailable(ref cause) => write!(f, "{}", cause),
1693            CreateReplicationJobError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
1694            CreateReplicationJobError::ReplicationJobAlreadyExists(ref cause) => {
1695                write!(f, "{}", cause)
1696            }
1697            CreateReplicationJobError::ServerCannotBeReplicated(ref cause) => {
1698                write!(f, "{}", cause)
1699            }
1700            CreateReplicationJobError::TemporarilyUnavailable(ref cause) => write!(f, "{}", cause),
1701            CreateReplicationJobError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
1702        }
1703    }
1704}
1705impl Error for CreateReplicationJobError {}
1706/// Errors returned by DeleteApp
1707#[derive(Debug, PartialEq)]
1708pub enum DeleteAppError {
1709    /// <p>An internal error occurred.</p>
1710    InternalError(String),
1711    /// <p>A specified parameter is not valid.</p>
1712    InvalidParameter(String),
1713    /// <p>A required parameter is missing.</p>
1714    MissingRequiredParameter(String),
1715    /// <p>This operation is not allowed.</p>
1716    OperationNotPermitted(String),
1717    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
1718    UnauthorizedOperation(String),
1719}
1720
1721impl DeleteAppError {
1722    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAppError> {
1723        if let Some(err) = proto::json::Error::parse(&res) {
1724            match err.typ.as_str() {
1725                "InternalError" => {
1726                    return RusotoError::Service(DeleteAppError::InternalError(err.msg))
1727                }
1728                "InvalidParameterException" => {
1729                    return RusotoError::Service(DeleteAppError::InvalidParameter(err.msg))
1730                }
1731                "MissingRequiredParameterException" => {
1732                    return RusotoError::Service(DeleteAppError::MissingRequiredParameter(err.msg))
1733                }
1734                "OperationNotPermittedException" => {
1735                    return RusotoError::Service(DeleteAppError::OperationNotPermitted(err.msg))
1736                }
1737                "UnauthorizedOperationException" => {
1738                    return RusotoError::Service(DeleteAppError::UnauthorizedOperation(err.msg))
1739                }
1740                "ValidationException" => return RusotoError::Validation(err.msg),
1741                _ => {}
1742            }
1743        }
1744        RusotoError::Unknown(res)
1745    }
1746}
1747impl fmt::Display for DeleteAppError {
1748    #[allow(unused_variables)]
1749    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1750        match *self {
1751            DeleteAppError::InternalError(ref cause) => write!(f, "{}", cause),
1752            DeleteAppError::InvalidParameter(ref cause) => write!(f, "{}", cause),
1753            DeleteAppError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
1754            DeleteAppError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
1755            DeleteAppError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
1756        }
1757    }
1758}
1759impl Error for DeleteAppError {}
1760/// Errors returned by DeleteAppLaunchConfiguration
1761#[derive(Debug, PartialEq)]
1762pub enum DeleteAppLaunchConfigurationError {
1763    /// <p>An internal error occurred.</p>
1764    InternalError(String),
1765    /// <p>A specified parameter is not valid.</p>
1766    InvalidParameter(String),
1767    /// <p>A required parameter is missing.</p>
1768    MissingRequiredParameter(String),
1769    /// <p>This operation is not allowed.</p>
1770    OperationNotPermitted(String),
1771    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
1772    UnauthorizedOperation(String),
1773}
1774
1775impl DeleteAppLaunchConfigurationError {
1776    pub fn from_response(
1777        res: BufferedHttpResponse,
1778    ) -> RusotoError<DeleteAppLaunchConfigurationError> {
1779        if let Some(err) = proto::json::Error::parse(&res) {
1780            match err.typ.as_str() {
1781                "InternalError" => {
1782                    return RusotoError::Service(DeleteAppLaunchConfigurationError::InternalError(
1783                        err.msg,
1784                    ))
1785                }
1786                "InvalidParameterException" => {
1787                    return RusotoError::Service(
1788                        DeleteAppLaunchConfigurationError::InvalidParameter(err.msg),
1789                    )
1790                }
1791                "MissingRequiredParameterException" => {
1792                    return RusotoError::Service(
1793                        DeleteAppLaunchConfigurationError::MissingRequiredParameter(err.msg),
1794                    )
1795                }
1796                "OperationNotPermittedException" => {
1797                    return RusotoError::Service(
1798                        DeleteAppLaunchConfigurationError::OperationNotPermitted(err.msg),
1799                    )
1800                }
1801                "UnauthorizedOperationException" => {
1802                    return RusotoError::Service(
1803                        DeleteAppLaunchConfigurationError::UnauthorizedOperation(err.msg),
1804                    )
1805                }
1806                "ValidationException" => return RusotoError::Validation(err.msg),
1807                _ => {}
1808            }
1809        }
1810        RusotoError::Unknown(res)
1811    }
1812}
1813impl fmt::Display for DeleteAppLaunchConfigurationError {
1814    #[allow(unused_variables)]
1815    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1816        match *self {
1817            DeleteAppLaunchConfigurationError::InternalError(ref cause) => write!(f, "{}", cause),
1818            DeleteAppLaunchConfigurationError::InvalidParameter(ref cause) => {
1819                write!(f, "{}", cause)
1820            }
1821            DeleteAppLaunchConfigurationError::MissingRequiredParameter(ref cause) => {
1822                write!(f, "{}", cause)
1823            }
1824            DeleteAppLaunchConfigurationError::OperationNotPermitted(ref cause) => {
1825                write!(f, "{}", cause)
1826            }
1827            DeleteAppLaunchConfigurationError::UnauthorizedOperation(ref cause) => {
1828                write!(f, "{}", cause)
1829            }
1830        }
1831    }
1832}
1833impl Error for DeleteAppLaunchConfigurationError {}
1834/// Errors returned by DeleteAppReplicationConfiguration
1835#[derive(Debug, PartialEq)]
1836pub enum DeleteAppReplicationConfigurationError {
1837    /// <p>An internal error occurred.</p>
1838    InternalError(String),
1839    /// <p>A specified parameter is not valid.</p>
1840    InvalidParameter(String),
1841    /// <p>A required parameter is missing.</p>
1842    MissingRequiredParameter(String),
1843    /// <p>This operation is not allowed.</p>
1844    OperationNotPermitted(String),
1845    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
1846    UnauthorizedOperation(String),
1847}
1848
1849impl DeleteAppReplicationConfigurationError {
1850    pub fn from_response(
1851        res: BufferedHttpResponse,
1852    ) -> RusotoError<DeleteAppReplicationConfigurationError> {
1853        if let Some(err) = proto::json::Error::parse(&res) {
1854            match err.typ.as_str() {
1855                "InternalError" => {
1856                    return RusotoError::Service(
1857                        DeleteAppReplicationConfigurationError::InternalError(err.msg),
1858                    )
1859                }
1860                "InvalidParameterException" => {
1861                    return RusotoError::Service(
1862                        DeleteAppReplicationConfigurationError::InvalidParameter(err.msg),
1863                    )
1864                }
1865                "MissingRequiredParameterException" => {
1866                    return RusotoError::Service(
1867                        DeleteAppReplicationConfigurationError::MissingRequiredParameter(err.msg),
1868                    )
1869                }
1870                "OperationNotPermittedException" => {
1871                    return RusotoError::Service(
1872                        DeleteAppReplicationConfigurationError::OperationNotPermitted(err.msg),
1873                    )
1874                }
1875                "UnauthorizedOperationException" => {
1876                    return RusotoError::Service(
1877                        DeleteAppReplicationConfigurationError::UnauthorizedOperation(err.msg),
1878                    )
1879                }
1880                "ValidationException" => return RusotoError::Validation(err.msg),
1881                _ => {}
1882            }
1883        }
1884        RusotoError::Unknown(res)
1885    }
1886}
1887impl fmt::Display for DeleteAppReplicationConfigurationError {
1888    #[allow(unused_variables)]
1889    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1890        match *self {
1891            DeleteAppReplicationConfigurationError::InternalError(ref cause) => {
1892                write!(f, "{}", cause)
1893            }
1894            DeleteAppReplicationConfigurationError::InvalidParameter(ref cause) => {
1895                write!(f, "{}", cause)
1896            }
1897            DeleteAppReplicationConfigurationError::MissingRequiredParameter(ref cause) => {
1898                write!(f, "{}", cause)
1899            }
1900            DeleteAppReplicationConfigurationError::OperationNotPermitted(ref cause) => {
1901                write!(f, "{}", cause)
1902            }
1903            DeleteAppReplicationConfigurationError::UnauthorizedOperation(ref cause) => {
1904                write!(f, "{}", cause)
1905            }
1906        }
1907    }
1908}
1909impl Error for DeleteAppReplicationConfigurationError {}
1910/// Errors returned by DeleteAppValidationConfiguration
1911#[derive(Debug, PartialEq)]
1912pub enum DeleteAppValidationConfigurationError {
1913    /// <p>An internal error occurred.</p>
1914    InternalError(String),
1915    /// <p>A specified parameter is not valid.</p>
1916    InvalidParameter(String),
1917    /// <p>A required parameter is missing.</p>
1918    MissingRequiredParameter(String),
1919    /// <p>This operation is not allowed.</p>
1920    OperationNotPermitted(String),
1921    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
1922    UnauthorizedOperation(String),
1923}
1924
1925impl DeleteAppValidationConfigurationError {
1926    pub fn from_response(
1927        res: BufferedHttpResponse,
1928    ) -> RusotoError<DeleteAppValidationConfigurationError> {
1929        if let Some(err) = proto::json::Error::parse(&res) {
1930            match err.typ.as_str() {
1931                "InternalError" => {
1932                    return RusotoError::Service(
1933                        DeleteAppValidationConfigurationError::InternalError(err.msg),
1934                    )
1935                }
1936                "InvalidParameterException" => {
1937                    return RusotoError::Service(
1938                        DeleteAppValidationConfigurationError::InvalidParameter(err.msg),
1939                    )
1940                }
1941                "MissingRequiredParameterException" => {
1942                    return RusotoError::Service(
1943                        DeleteAppValidationConfigurationError::MissingRequiredParameter(err.msg),
1944                    )
1945                }
1946                "OperationNotPermittedException" => {
1947                    return RusotoError::Service(
1948                        DeleteAppValidationConfigurationError::OperationNotPermitted(err.msg),
1949                    )
1950                }
1951                "UnauthorizedOperationException" => {
1952                    return RusotoError::Service(
1953                        DeleteAppValidationConfigurationError::UnauthorizedOperation(err.msg),
1954                    )
1955                }
1956                "ValidationException" => return RusotoError::Validation(err.msg),
1957                _ => {}
1958            }
1959        }
1960        RusotoError::Unknown(res)
1961    }
1962}
1963impl fmt::Display for DeleteAppValidationConfigurationError {
1964    #[allow(unused_variables)]
1965    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1966        match *self {
1967            DeleteAppValidationConfigurationError::InternalError(ref cause) => {
1968                write!(f, "{}", cause)
1969            }
1970            DeleteAppValidationConfigurationError::InvalidParameter(ref cause) => {
1971                write!(f, "{}", cause)
1972            }
1973            DeleteAppValidationConfigurationError::MissingRequiredParameter(ref cause) => {
1974                write!(f, "{}", cause)
1975            }
1976            DeleteAppValidationConfigurationError::OperationNotPermitted(ref cause) => {
1977                write!(f, "{}", cause)
1978            }
1979            DeleteAppValidationConfigurationError::UnauthorizedOperation(ref cause) => {
1980                write!(f, "{}", cause)
1981            }
1982        }
1983    }
1984}
1985impl Error for DeleteAppValidationConfigurationError {}
1986/// Errors returned by DeleteReplicationJob
1987#[derive(Debug, PartialEq)]
1988pub enum DeleteReplicationJobError {
1989    /// <p>A specified parameter is not valid.</p>
1990    InvalidParameter(String),
1991    /// <p>A required parameter is missing.</p>
1992    MissingRequiredParameter(String),
1993    /// <p>This operation is not allowed.</p>
1994    OperationNotPermitted(String),
1995    /// <p>The specified replication job does not exist.</p>
1996    ReplicationJobNotFound(String),
1997    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
1998    UnauthorizedOperation(String),
1999}
2000
2001impl DeleteReplicationJobError {
2002    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteReplicationJobError> {
2003        if let Some(err) = proto::json::Error::parse(&res) {
2004            match err.typ.as_str() {
2005                "InvalidParameterException" => {
2006                    return RusotoError::Service(DeleteReplicationJobError::InvalidParameter(
2007                        err.msg,
2008                    ))
2009                }
2010                "MissingRequiredParameterException" => {
2011                    return RusotoError::Service(
2012                        DeleteReplicationJobError::MissingRequiredParameter(err.msg),
2013                    )
2014                }
2015                "OperationNotPermittedException" => {
2016                    return RusotoError::Service(DeleteReplicationJobError::OperationNotPermitted(
2017                        err.msg,
2018                    ))
2019                }
2020                "ReplicationJobNotFoundException" => {
2021                    return RusotoError::Service(DeleteReplicationJobError::ReplicationJobNotFound(
2022                        err.msg,
2023                    ))
2024                }
2025                "UnauthorizedOperationException" => {
2026                    return RusotoError::Service(DeleteReplicationJobError::UnauthorizedOperation(
2027                        err.msg,
2028                    ))
2029                }
2030                "ValidationException" => return RusotoError::Validation(err.msg),
2031                _ => {}
2032            }
2033        }
2034        RusotoError::Unknown(res)
2035    }
2036}
2037impl fmt::Display for DeleteReplicationJobError {
2038    #[allow(unused_variables)]
2039    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2040        match *self {
2041            DeleteReplicationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2042            DeleteReplicationJobError::MissingRequiredParameter(ref cause) => {
2043                write!(f, "{}", cause)
2044            }
2045            DeleteReplicationJobError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
2046            DeleteReplicationJobError::ReplicationJobNotFound(ref cause) => write!(f, "{}", cause),
2047            DeleteReplicationJobError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
2048        }
2049    }
2050}
2051impl Error for DeleteReplicationJobError {}
2052/// Errors returned by DeleteServerCatalog
2053#[derive(Debug, PartialEq)]
2054pub enum DeleteServerCatalogError {
2055    /// <p>A specified parameter is not valid.</p>
2056    InvalidParameter(String),
2057    /// <p>A required parameter is missing.</p>
2058    MissingRequiredParameter(String),
2059    /// <p>This operation is not allowed.</p>
2060    OperationNotPermitted(String),
2061    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2062    UnauthorizedOperation(String),
2063}
2064
2065impl DeleteServerCatalogError {
2066    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteServerCatalogError> {
2067        if let Some(err) = proto::json::Error::parse(&res) {
2068            match err.typ.as_str() {
2069                "InvalidParameterException" => {
2070                    return RusotoError::Service(DeleteServerCatalogError::InvalidParameter(
2071                        err.msg,
2072                    ))
2073                }
2074                "MissingRequiredParameterException" => {
2075                    return RusotoError::Service(
2076                        DeleteServerCatalogError::MissingRequiredParameter(err.msg),
2077                    )
2078                }
2079                "OperationNotPermittedException" => {
2080                    return RusotoError::Service(DeleteServerCatalogError::OperationNotPermitted(
2081                        err.msg,
2082                    ))
2083                }
2084                "UnauthorizedOperationException" => {
2085                    return RusotoError::Service(DeleteServerCatalogError::UnauthorizedOperation(
2086                        err.msg,
2087                    ))
2088                }
2089                "ValidationException" => return RusotoError::Validation(err.msg),
2090                _ => {}
2091            }
2092        }
2093        RusotoError::Unknown(res)
2094    }
2095}
2096impl fmt::Display for DeleteServerCatalogError {
2097    #[allow(unused_variables)]
2098    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2099        match *self {
2100            DeleteServerCatalogError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2101            DeleteServerCatalogError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
2102            DeleteServerCatalogError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
2103            DeleteServerCatalogError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
2104        }
2105    }
2106}
2107impl Error for DeleteServerCatalogError {}
2108/// Errors returned by DisassociateConnector
2109#[derive(Debug, PartialEq)]
2110pub enum DisassociateConnectorError {
2111    /// <p>A specified parameter is not valid.</p>
2112    InvalidParameter(String),
2113    /// <p>A required parameter is missing.</p>
2114    MissingRequiredParameter(String),
2115    /// <p>This operation is not allowed.</p>
2116    OperationNotPermitted(String),
2117    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2118    UnauthorizedOperation(String),
2119}
2120
2121impl DisassociateConnectorError {
2122    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisassociateConnectorError> {
2123        if let Some(err) = proto::json::Error::parse(&res) {
2124            match err.typ.as_str() {
2125                "InvalidParameterException" => {
2126                    return RusotoError::Service(DisassociateConnectorError::InvalidParameter(
2127                        err.msg,
2128                    ))
2129                }
2130                "MissingRequiredParameterException" => {
2131                    return RusotoError::Service(
2132                        DisassociateConnectorError::MissingRequiredParameter(err.msg),
2133                    )
2134                }
2135                "OperationNotPermittedException" => {
2136                    return RusotoError::Service(DisassociateConnectorError::OperationNotPermitted(
2137                        err.msg,
2138                    ))
2139                }
2140                "UnauthorizedOperationException" => {
2141                    return RusotoError::Service(DisassociateConnectorError::UnauthorizedOperation(
2142                        err.msg,
2143                    ))
2144                }
2145                "ValidationException" => return RusotoError::Validation(err.msg),
2146                _ => {}
2147            }
2148        }
2149        RusotoError::Unknown(res)
2150    }
2151}
2152impl fmt::Display for DisassociateConnectorError {
2153    #[allow(unused_variables)]
2154    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2155        match *self {
2156            DisassociateConnectorError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2157            DisassociateConnectorError::MissingRequiredParameter(ref cause) => {
2158                write!(f, "{}", cause)
2159            }
2160            DisassociateConnectorError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
2161            DisassociateConnectorError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
2162        }
2163    }
2164}
2165impl Error for DisassociateConnectorError {}
2166/// Errors returned by GenerateChangeSet
2167#[derive(Debug, PartialEq)]
2168pub enum GenerateChangeSetError {
2169    /// <p>An internal error occurred.</p>
2170    InternalError(String),
2171    /// <p>A specified parameter is not valid.</p>
2172    InvalidParameter(String),
2173    /// <p>A required parameter is missing.</p>
2174    MissingRequiredParameter(String),
2175    /// <p>This operation is not allowed.</p>
2176    OperationNotPermitted(String),
2177    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2178    UnauthorizedOperation(String),
2179}
2180
2181impl GenerateChangeSetError {
2182    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GenerateChangeSetError> {
2183        if let Some(err) = proto::json::Error::parse(&res) {
2184            match err.typ.as_str() {
2185                "InternalError" => {
2186                    return RusotoError::Service(GenerateChangeSetError::InternalError(err.msg))
2187                }
2188                "InvalidParameterException" => {
2189                    return RusotoError::Service(GenerateChangeSetError::InvalidParameter(err.msg))
2190                }
2191                "MissingRequiredParameterException" => {
2192                    return RusotoError::Service(GenerateChangeSetError::MissingRequiredParameter(
2193                        err.msg,
2194                    ))
2195                }
2196                "OperationNotPermittedException" => {
2197                    return RusotoError::Service(GenerateChangeSetError::OperationNotPermitted(
2198                        err.msg,
2199                    ))
2200                }
2201                "UnauthorizedOperationException" => {
2202                    return RusotoError::Service(GenerateChangeSetError::UnauthorizedOperation(
2203                        err.msg,
2204                    ))
2205                }
2206                "ValidationException" => return RusotoError::Validation(err.msg),
2207                _ => {}
2208            }
2209        }
2210        RusotoError::Unknown(res)
2211    }
2212}
2213impl fmt::Display for GenerateChangeSetError {
2214    #[allow(unused_variables)]
2215    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2216        match *self {
2217            GenerateChangeSetError::InternalError(ref cause) => write!(f, "{}", cause),
2218            GenerateChangeSetError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2219            GenerateChangeSetError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
2220            GenerateChangeSetError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
2221            GenerateChangeSetError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
2222        }
2223    }
2224}
2225impl Error for GenerateChangeSetError {}
2226/// Errors returned by GenerateTemplate
2227#[derive(Debug, PartialEq)]
2228pub enum GenerateTemplateError {
2229    /// <p>An internal error occurred.</p>
2230    InternalError(String),
2231    /// <p>A specified parameter is not valid.</p>
2232    InvalidParameter(String),
2233    /// <p>A required parameter is missing.</p>
2234    MissingRequiredParameter(String),
2235    /// <p>This operation is not allowed.</p>
2236    OperationNotPermitted(String),
2237    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2238    UnauthorizedOperation(String),
2239}
2240
2241impl GenerateTemplateError {
2242    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GenerateTemplateError> {
2243        if let Some(err) = proto::json::Error::parse(&res) {
2244            match err.typ.as_str() {
2245                "InternalError" => {
2246                    return RusotoError::Service(GenerateTemplateError::InternalError(err.msg))
2247                }
2248                "InvalidParameterException" => {
2249                    return RusotoError::Service(GenerateTemplateError::InvalidParameter(err.msg))
2250                }
2251                "MissingRequiredParameterException" => {
2252                    return RusotoError::Service(GenerateTemplateError::MissingRequiredParameter(
2253                        err.msg,
2254                    ))
2255                }
2256                "OperationNotPermittedException" => {
2257                    return RusotoError::Service(GenerateTemplateError::OperationNotPermitted(
2258                        err.msg,
2259                    ))
2260                }
2261                "UnauthorizedOperationException" => {
2262                    return RusotoError::Service(GenerateTemplateError::UnauthorizedOperation(
2263                        err.msg,
2264                    ))
2265                }
2266                "ValidationException" => return RusotoError::Validation(err.msg),
2267                _ => {}
2268            }
2269        }
2270        RusotoError::Unknown(res)
2271    }
2272}
2273impl fmt::Display for GenerateTemplateError {
2274    #[allow(unused_variables)]
2275    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2276        match *self {
2277            GenerateTemplateError::InternalError(ref cause) => write!(f, "{}", cause),
2278            GenerateTemplateError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2279            GenerateTemplateError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
2280            GenerateTemplateError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
2281            GenerateTemplateError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
2282        }
2283    }
2284}
2285impl Error for GenerateTemplateError {}
2286/// Errors returned by GetApp
2287#[derive(Debug, PartialEq)]
2288pub enum GetAppError {
2289    /// <p>An internal error occurred.</p>
2290    InternalError(String),
2291    /// <p>A specified parameter is not valid.</p>
2292    InvalidParameter(String),
2293    /// <p>A required parameter is missing.</p>
2294    MissingRequiredParameter(String),
2295    /// <p>This operation is not allowed.</p>
2296    OperationNotPermitted(String),
2297    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2298    UnauthorizedOperation(String),
2299}
2300
2301impl GetAppError {
2302    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAppError> {
2303        if let Some(err) = proto::json::Error::parse(&res) {
2304            match err.typ.as_str() {
2305                "InternalError" => {
2306                    return RusotoError::Service(GetAppError::InternalError(err.msg))
2307                }
2308                "InvalidParameterException" => {
2309                    return RusotoError::Service(GetAppError::InvalidParameter(err.msg))
2310                }
2311                "MissingRequiredParameterException" => {
2312                    return RusotoError::Service(GetAppError::MissingRequiredParameter(err.msg))
2313                }
2314                "OperationNotPermittedException" => {
2315                    return RusotoError::Service(GetAppError::OperationNotPermitted(err.msg))
2316                }
2317                "UnauthorizedOperationException" => {
2318                    return RusotoError::Service(GetAppError::UnauthorizedOperation(err.msg))
2319                }
2320                "ValidationException" => return RusotoError::Validation(err.msg),
2321                _ => {}
2322            }
2323        }
2324        RusotoError::Unknown(res)
2325    }
2326}
2327impl fmt::Display for GetAppError {
2328    #[allow(unused_variables)]
2329    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2330        match *self {
2331            GetAppError::InternalError(ref cause) => write!(f, "{}", cause),
2332            GetAppError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2333            GetAppError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
2334            GetAppError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
2335            GetAppError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
2336        }
2337    }
2338}
2339impl Error for GetAppError {}
2340/// Errors returned by GetAppLaunchConfiguration
2341#[derive(Debug, PartialEq)]
2342pub enum GetAppLaunchConfigurationError {
2343    /// <p>An internal error occurred.</p>
2344    InternalError(String),
2345    /// <p>A specified parameter is not valid.</p>
2346    InvalidParameter(String),
2347    /// <p>A required parameter is missing.</p>
2348    MissingRequiredParameter(String),
2349    /// <p>This operation is not allowed.</p>
2350    OperationNotPermitted(String),
2351    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2352    UnauthorizedOperation(String),
2353}
2354
2355impl GetAppLaunchConfigurationError {
2356    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAppLaunchConfigurationError> {
2357        if let Some(err) = proto::json::Error::parse(&res) {
2358            match err.typ.as_str() {
2359                "InternalError" => {
2360                    return RusotoError::Service(GetAppLaunchConfigurationError::InternalError(
2361                        err.msg,
2362                    ))
2363                }
2364                "InvalidParameterException" => {
2365                    return RusotoError::Service(GetAppLaunchConfigurationError::InvalidParameter(
2366                        err.msg,
2367                    ))
2368                }
2369                "MissingRequiredParameterException" => {
2370                    return RusotoError::Service(
2371                        GetAppLaunchConfigurationError::MissingRequiredParameter(err.msg),
2372                    )
2373                }
2374                "OperationNotPermittedException" => {
2375                    return RusotoError::Service(
2376                        GetAppLaunchConfigurationError::OperationNotPermitted(err.msg),
2377                    )
2378                }
2379                "UnauthorizedOperationException" => {
2380                    return RusotoError::Service(
2381                        GetAppLaunchConfigurationError::UnauthorizedOperation(err.msg),
2382                    )
2383                }
2384                "ValidationException" => return RusotoError::Validation(err.msg),
2385                _ => {}
2386            }
2387        }
2388        RusotoError::Unknown(res)
2389    }
2390}
2391impl fmt::Display for GetAppLaunchConfigurationError {
2392    #[allow(unused_variables)]
2393    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2394        match *self {
2395            GetAppLaunchConfigurationError::InternalError(ref cause) => write!(f, "{}", cause),
2396            GetAppLaunchConfigurationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2397            GetAppLaunchConfigurationError::MissingRequiredParameter(ref cause) => {
2398                write!(f, "{}", cause)
2399            }
2400            GetAppLaunchConfigurationError::OperationNotPermitted(ref cause) => {
2401                write!(f, "{}", cause)
2402            }
2403            GetAppLaunchConfigurationError::UnauthorizedOperation(ref cause) => {
2404                write!(f, "{}", cause)
2405            }
2406        }
2407    }
2408}
2409impl Error for GetAppLaunchConfigurationError {}
2410/// Errors returned by GetAppReplicationConfiguration
2411#[derive(Debug, PartialEq)]
2412pub enum GetAppReplicationConfigurationError {
2413    /// <p>An internal error occurred.</p>
2414    InternalError(String),
2415    /// <p>A specified parameter is not valid.</p>
2416    InvalidParameter(String),
2417    /// <p>A required parameter is missing.</p>
2418    MissingRequiredParameter(String),
2419    /// <p>This operation is not allowed.</p>
2420    OperationNotPermitted(String),
2421    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2422    UnauthorizedOperation(String),
2423}
2424
2425impl GetAppReplicationConfigurationError {
2426    pub fn from_response(
2427        res: BufferedHttpResponse,
2428    ) -> RusotoError<GetAppReplicationConfigurationError> {
2429        if let Some(err) = proto::json::Error::parse(&res) {
2430            match err.typ.as_str() {
2431                "InternalError" => {
2432                    return RusotoError::Service(
2433                        GetAppReplicationConfigurationError::InternalError(err.msg),
2434                    )
2435                }
2436                "InvalidParameterException" => {
2437                    return RusotoError::Service(
2438                        GetAppReplicationConfigurationError::InvalidParameter(err.msg),
2439                    )
2440                }
2441                "MissingRequiredParameterException" => {
2442                    return RusotoError::Service(
2443                        GetAppReplicationConfigurationError::MissingRequiredParameter(err.msg),
2444                    )
2445                }
2446                "OperationNotPermittedException" => {
2447                    return RusotoError::Service(
2448                        GetAppReplicationConfigurationError::OperationNotPermitted(err.msg),
2449                    )
2450                }
2451                "UnauthorizedOperationException" => {
2452                    return RusotoError::Service(
2453                        GetAppReplicationConfigurationError::UnauthorizedOperation(err.msg),
2454                    )
2455                }
2456                "ValidationException" => return RusotoError::Validation(err.msg),
2457                _ => {}
2458            }
2459        }
2460        RusotoError::Unknown(res)
2461    }
2462}
2463impl fmt::Display for GetAppReplicationConfigurationError {
2464    #[allow(unused_variables)]
2465    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2466        match *self {
2467            GetAppReplicationConfigurationError::InternalError(ref cause) => write!(f, "{}", cause),
2468            GetAppReplicationConfigurationError::InvalidParameter(ref cause) => {
2469                write!(f, "{}", cause)
2470            }
2471            GetAppReplicationConfigurationError::MissingRequiredParameter(ref cause) => {
2472                write!(f, "{}", cause)
2473            }
2474            GetAppReplicationConfigurationError::OperationNotPermitted(ref cause) => {
2475                write!(f, "{}", cause)
2476            }
2477            GetAppReplicationConfigurationError::UnauthorizedOperation(ref cause) => {
2478                write!(f, "{}", cause)
2479            }
2480        }
2481    }
2482}
2483impl Error for GetAppReplicationConfigurationError {}
2484/// Errors returned by GetAppValidationConfiguration
2485#[derive(Debug, PartialEq)]
2486pub enum GetAppValidationConfigurationError {
2487    /// <p>An internal error occurred.</p>
2488    InternalError(String),
2489    /// <p>A specified parameter is not valid.</p>
2490    InvalidParameter(String),
2491    /// <p>A required parameter is missing.</p>
2492    MissingRequiredParameter(String),
2493    /// <p>This operation is not allowed.</p>
2494    OperationNotPermitted(String),
2495    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2496    UnauthorizedOperation(String),
2497}
2498
2499impl GetAppValidationConfigurationError {
2500    pub fn from_response(
2501        res: BufferedHttpResponse,
2502    ) -> RusotoError<GetAppValidationConfigurationError> {
2503        if let Some(err) = proto::json::Error::parse(&res) {
2504            match err.typ.as_str() {
2505                "InternalError" => {
2506                    return RusotoError::Service(GetAppValidationConfigurationError::InternalError(
2507                        err.msg,
2508                    ))
2509                }
2510                "InvalidParameterException" => {
2511                    return RusotoError::Service(
2512                        GetAppValidationConfigurationError::InvalidParameter(err.msg),
2513                    )
2514                }
2515                "MissingRequiredParameterException" => {
2516                    return RusotoError::Service(
2517                        GetAppValidationConfigurationError::MissingRequiredParameter(err.msg),
2518                    )
2519                }
2520                "OperationNotPermittedException" => {
2521                    return RusotoError::Service(
2522                        GetAppValidationConfigurationError::OperationNotPermitted(err.msg),
2523                    )
2524                }
2525                "UnauthorizedOperationException" => {
2526                    return RusotoError::Service(
2527                        GetAppValidationConfigurationError::UnauthorizedOperation(err.msg),
2528                    )
2529                }
2530                "ValidationException" => return RusotoError::Validation(err.msg),
2531                _ => {}
2532            }
2533        }
2534        RusotoError::Unknown(res)
2535    }
2536}
2537impl fmt::Display for GetAppValidationConfigurationError {
2538    #[allow(unused_variables)]
2539    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2540        match *self {
2541            GetAppValidationConfigurationError::InternalError(ref cause) => write!(f, "{}", cause),
2542            GetAppValidationConfigurationError::InvalidParameter(ref cause) => {
2543                write!(f, "{}", cause)
2544            }
2545            GetAppValidationConfigurationError::MissingRequiredParameter(ref cause) => {
2546                write!(f, "{}", cause)
2547            }
2548            GetAppValidationConfigurationError::OperationNotPermitted(ref cause) => {
2549                write!(f, "{}", cause)
2550            }
2551            GetAppValidationConfigurationError::UnauthorizedOperation(ref cause) => {
2552                write!(f, "{}", cause)
2553            }
2554        }
2555    }
2556}
2557impl Error for GetAppValidationConfigurationError {}
2558/// Errors returned by GetAppValidationOutput
2559#[derive(Debug, PartialEq)]
2560pub enum GetAppValidationOutputError {
2561    /// <p>An internal error occurred.</p>
2562    InternalError(String),
2563    /// <p>A specified parameter is not valid.</p>
2564    InvalidParameter(String),
2565    /// <p>A required parameter is missing.</p>
2566    MissingRequiredParameter(String),
2567    /// <p>This operation is not allowed.</p>
2568    OperationNotPermitted(String),
2569    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2570    UnauthorizedOperation(String),
2571}
2572
2573impl GetAppValidationOutputError {
2574    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAppValidationOutputError> {
2575        if let Some(err) = proto::json::Error::parse(&res) {
2576            match err.typ.as_str() {
2577                "InternalError" => {
2578                    return RusotoError::Service(GetAppValidationOutputError::InternalError(
2579                        err.msg,
2580                    ))
2581                }
2582                "InvalidParameterException" => {
2583                    return RusotoError::Service(GetAppValidationOutputError::InvalidParameter(
2584                        err.msg,
2585                    ))
2586                }
2587                "MissingRequiredParameterException" => {
2588                    return RusotoError::Service(
2589                        GetAppValidationOutputError::MissingRequiredParameter(err.msg),
2590                    )
2591                }
2592                "OperationNotPermittedException" => {
2593                    return RusotoError::Service(
2594                        GetAppValidationOutputError::OperationNotPermitted(err.msg),
2595                    )
2596                }
2597                "UnauthorizedOperationException" => {
2598                    return RusotoError::Service(
2599                        GetAppValidationOutputError::UnauthorizedOperation(err.msg),
2600                    )
2601                }
2602                "ValidationException" => return RusotoError::Validation(err.msg),
2603                _ => {}
2604            }
2605        }
2606        RusotoError::Unknown(res)
2607    }
2608}
2609impl fmt::Display for GetAppValidationOutputError {
2610    #[allow(unused_variables)]
2611    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2612        match *self {
2613            GetAppValidationOutputError::InternalError(ref cause) => write!(f, "{}", cause),
2614            GetAppValidationOutputError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2615            GetAppValidationOutputError::MissingRequiredParameter(ref cause) => {
2616                write!(f, "{}", cause)
2617            }
2618            GetAppValidationOutputError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
2619            GetAppValidationOutputError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
2620        }
2621    }
2622}
2623impl Error for GetAppValidationOutputError {}
2624/// Errors returned by GetConnectors
2625#[derive(Debug, PartialEq)]
2626pub enum GetConnectorsError {
2627    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2628    UnauthorizedOperation(String),
2629}
2630
2631impl GetConnectorsError {
2632    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetConnectorsError> {
2633        if let Some(err) = proto::json::Error::parse(&res) {
2634            match err.typ.as_str() {
2635                "UnauthorizedOperationException" => {
2636                    return RusotoError::Service(GetConnectorsError::UnauthorizedOperation(err.msg))
2637                }
2638                "ValidationException" => return RusotoError::Validation(err.msg),
2639                _ => {}
2640            }
2641        }
2642        RusotoError::Unknown(res)
2643    }
2644}
2645impl fmt::Display for GetConnectorsError {
2646    #[allow(unused_variables)]
2647    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2648        match *self {
2649            GetConnectorsError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
2650        }
2651    }
2652}
2653impl Error for GetConnectorsError {}
2654/// Errors returned by GetReplicationJobs
2655#[derive(Debug, PartialEq)]
2656pub enum GetReplicationJobsError {
2657    /// <p>A specified parameter is not valid.</p>
2658    InvalidParameter(String),
2659    /// <p>A required parameter is missing.</p>
2660    MissingRequiredParameter(String),
2661    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2662    UnauthorizedOperation(String),
2663}
2664
2665impl GetReplicationJobsError {
2666    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetReplicationJobsError> {
2667        if let Some(err) = proto::json::Error::parse(&res) {
2668            match err.typ.as_str() {
2669                "InvalidParameterException" => {
2670                    return RusotoError::Service(GetReplicationJobsError::InvalidParameter(err.msg))
2671                }
2672                "MissingRequiredParameterException" => {
2673                    return RusotoError::Service(GetReplicationJobsError::MissingRequiredParameter(
2674                        err.msg,
2675                    ))
2676                }
2677                "UnauthorizedOperationException" => {
2678                    return RusotoError::Service(GetReplicationJobsError::UnauthorizedOperation(
2679                        err.msg,
2680                    ))
2681                }
2682                "ValidationException" => return RusotoError::Validation(err.msg),
2683                _ => {}
2684            }
2685        }
2686        RusotoError::Unknown(res)
2687    }
2688}
2689impl fmt::Display for GetReplicationJobsError {
2690    #[allow(unused_variables)]
2691    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2692        match *self {
2693            GetReplicationJobsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2694            GetReplicationJobsError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
2695            GetReplicationJobsError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
2696        }
2697    }
2698}
2699impl Error for GetReplicationJobsError {}
2700/// Errors returned by GetReplicationRuns
2701#[derive(Debug, PartialEq)]
2702pub enum GetReplicationRunsError {
2703    /// <p>A specified parameter is not valid.</p>
2704    InvalidParameter(String),
2705    /// <p>A required parameter is missing.</p>
2706    MissingRequiredParameter(String),
2707    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2708    UnauthorizedOperation(String),
2709}
2710
2711impl GetReplicationRunsError {
2712    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetReplicationRunsError> {
2713        if let Some(err) = proto::json::Error::parse(&res) {
2714            match err.typ.as_str() {
2715                "InvalidParameterException" => {
2716                    return RusotoError::Service(GetReplicationRunsError::InvalidParameter(err.msg))
2717                }
2718                "MissingRequiredParameterException" => {
2719                    return RusotoError::Service(GetReplicationRunsError::MissingRequiredParameter(
2720                        err.msg,
2721                    ))
2722                }
2723                "UnauthorizedOperationException" => {
2724                    return RusotoError::Service(GetReplicationRunsError::UnauthorizedOperation(
2725                        err.msg,
2726                    ))
2727                }
2728                "ValidationException" => return RusotoError::Validation(err.msg),
2729                _ => {}
2730            }
2731        }
2732        RusotoError::Unknown(res)
2733    }
2734}
2735impl fmt::Display for GetReplicationRunsError {
2736    #[allow(unused_variables)]
2737    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2738        match *self {
2739            GetReplicationRunsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2740            GetReplicationRunsError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
2741            GetReplicationRunsError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
2742        }
2743    }
2744}
2745impl Error for GetReplicationRunsError {}
2746/// Errors returned by GetServers
2747#[derive(Debug, PartialEq)]
2748pub enum GetServersError {
2749    /// <p>An internal error occurred.</p>
2750    InternalError(String),
2751    /// <p>A specified parameter is not valid.</p>
2752    InvalidParameter(String),
2753    /// <p>A required parameter is missing.</p>
2754    MissingRequiredParameter(String),
2755    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2756    UnauthorizedOperation(String),
2757}
2758
2759impl GetServersError {
2760    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetServersError> {
2761        if let Some(err) = proto::json::Error::parse(&res) {
2762            match err.typ.as_str() {
2763                "InternalError" => {
2764                    return RusotoError::Service(GetServersError::InternalError(err.msg))
2765                }
2766                "InvalidParameterException" => {
2767                    return RusotoError::Service(GetServersError::InvalidParameter(err.msg))
2768                }
2769                "MissingRequiredParameterException" => {
2770                    return RusotoError::Service(GetServersError::MissingRequiredParameter(err.msg))
2771                }
2772                "UnauthorizedOperationException" => {
2773                    return RusotoError::Service(GetServersError::UnauthorizedOperation(err.msg))
2774                }
2775                "ValidationException" => return RusotoError::Validation(err.msg),
2776                _ => {}
2777            }
2778        }
2779        RusotoError::Unknown(res)
2780    }
2781}
2782impl fmt::Display for GetServersError {
2783    #[allow(unused_variables)]
2784    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2785        match *self {
2786            GetServersError::InternalError(ref cause) => write!(f, "{}", cause),
2787            GetServersError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2788            GetServersError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
2789            GetServersError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
2790        }
2791    }
2792}
2793impl Error for GetServersError {}
2794/// Errors returned by ImportAppCatalog
2795#[derive(Debug, PartialEq)]
2796pub enum ImportAppCatalogError {
2797    /// <p>An internal error occurred.</p>
2798    InternalError(String),
2799    /// <p>A specified parameter is not valid.</p>
2800    InvalidParameter(String),
2801    /// <p>A required parameter is missing.</p>
2802    MissingRequiredParameter(String),
2803    /// <p>This operation is not allowed.</p>
2804    OperationNotPermitted(String),
2805    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2806    UnauthorizedOperation(String),
2807}
2808
2809impl ImportAppCatalogError {
2810    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ImportAppCatalogError> {
2811        if let Some(err) = proto::json::Error::parse(&res) {
2812            match err.typ.as_str() {
2813                "InternalError" => {
2814                    return RusotoError::Service(ImportAppCatalogError::InternalError(err.msg))
2815                }
2816                "InvalidParameterException" => {
2817                    return RusotoError::Service(ImportAppCatalogError::InvalidParameter(err.msg))
2818                }
2819                "MissingRequiredParameterException" => {
2820                    return RusotoError::Service(ImportAppCatalogError::MissingRequiredParameter(
2821                        err.msg,
2822                    ))
2823                }
2824                "OperationNotPermittedException" => {
2825                    return RusotoError::Service(ImportAppCatalogError::OperationNotPermitted(
2826                        err.msg,
2827                    ))
2828                }
2829                "UnauthorizedOperationException" => {
2830                    return RusotoError::Service(ImportAppCatalogError::UnauthorizedOperation(
2831                        err.msg,
2832                    ))
2833                }
2834                "ValidationException" => return RusotoError::Validation(err.msg),
2835                _ => {}
2836            }
2837        }
2838        RusotoError::Unknown(res)
2839    }
2840}
2841impl fmt::Display for ImportAppCatalogError {
2842    #[allow(unused_variables)]
2843    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2844        match *self {
2845            ImportAppCatalogError::InternalError(ref cause) => write!(f, "{}", cause),
2846            ImportAppCatalogError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2847            ImportAppCatalogError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
2848            ImportAppCatalogError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
2849            ImportAppCatalogError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
2850        }
2851    }
2852}
2853impl Error for ImportAppCatalogError {}
2854/// Errors returned by ImportServerCatalog
2855#[derive(Debug, PartialEq)]
2856pub enum ImportServerCatalogError {
2857    /// <p>A specified parameter is not valid.</p>
2858    InvalidParameter(String),
2859    /// <p>A required parameter is missing.</p>
2860    MissingRequiredParameter(String),
2861    /// <p>There are no connectors available.</p>
2862    NoConnectorsAvailable(String),
2863    /// <p>This operation is not allowed.</p>
2864    OperationNotPermitted(String),
2865    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2866    UnauthorizedOperation(String),
2867}
2868
2869impl ImportServerCatalogError {
2870    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ImportServerCatalogError> {
2871        if let Some(err) = proto::json::Error::parse(&res) {
2872            match err.typ.as_str() {
2873                "InvalidParameterException" => {
2874                    return RusotoError::Service(ImportServerCatalogError::InvalidParameter(
2875                        err.msg,
2876                    ))
2877                }
2878                "MissingRequiredParameterException" => {
2879                    return RusotoError::Service(
2880                        ImportServerCatalogError::MissingRequiredParameter(err.msg),
2881                    )
2882                }
2883                "NoConnectorsAvailableException" => {
2884                    return RusotoError::Service(ImportServerCatalogError::NoConnectorsAvailable(
2885                        err.msg,
2886                    ))
2887                }
2888                "OperationNotPermittedException" => {
2889                    return RusotoError::Service(ImportServerCatalogError::OperationNotPermitted(
2890                        err.msg,
2891                    ))
2892                }
2893                "UnauthorizedOperationException" => {
2894                    return RusotoError::Service(ImportServerCatalogError::UnauthorizedOperation(
2895                        err.msg,
2896                    ))
2897                }
2898                "ValidationException" => return RusotoError::Validation(err.msg),
2899                _ => {}
2900            }
2901        }
2902        RusotoError::Unknown(res)
2903    }
2904}
2905impl fmt::Display for ImportServerCatalogError {
2906    #[allow(unused_variables)]
2907    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2908        match *self {
2909            ImportServerCatalogError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2910            ImportServerCatalogError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
2911            ImportServerCatalogError::NoConnectorsAvailable(ref cause) => write!(f, "{}", cause),
2912            ImportServerCatalogError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
2913            ImportServerCatalogError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
2914        }
2915    }
2916}
2917impl Error for ImportServerCatalogError {}
2918/// Errors returned by LaunchApp
2919#[derive(Debug, PartialEq)]
2920pub enum LaunchAppError {
2921    /// <p>An internal error occurred.</p>
2922    InternalError(String),
2923    /// <p>A specified parameter is not valid.</p>
2924    InvalidParameter(String),
2925    /// <p>A required parameter is missing.</p>
2926    MissingRequiredParameter(String),
2927    /// <p>This operation is not allowed.</p>
2928    OperationNotPermitted(String),
2929    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2930    UnauthorizedOperation(String),
2931}
2932
2933impl LaunchAppError {
2934    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<LaunchAppError> {
2935        if let Some(err) = proto::json::Error::parse(&res) {
2936            match err.typ.as_str() {
2937                "InternalError" => {
2938                    return RusotoError::Service(LaunchAppError::InternalError(err.msg))
2939                }
2940                "InvalidParameterException" => {
2941                    return RusotoError::Service(LaunchAppError::InvalidParameter(err.msg))
2942                }
2943                "MissingRequiredParameterException" => {
2944                    return RusotoError::Service(LaunchAppError::MissingRequiredParameter(err.msg))
2945                }
2946                "OperationNotPermittedException" => {
2947                    return RusotoError::Service(LaunchAppError::OperationNotPermitted(err.msg))
2948                }
2949                "UnauthorizedOperationException" => {
2950                    return RusotoError::Service(LaunchAppError::UnauthorizedOperation(err.msg))
2951                }
2952                "ValidationException" => return RusotoError::Validation(err.msg),
2953                _ => {}
2954            }
2955        }
2956        RusotoError::Unknown(res)
2957    }
2958}
2959impl fmt::Display for LaunchAppError {
2960    #[allow(unused_variables)]
2961    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2962        match *self {
2963            LaunchAppError::InternalError(ref cause) => write!(f, "{}", cause),
2964            LaunchAppError::InvalidParameter(ref cause) => write!(f, "{}", cause),
2965            LaunchAppError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
2966            LaunchAppError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
2967            LaunchAppError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
2968        }
2969    }
2970}
2971impl Error for LaunchAppError {}
2972/// Errors returned by ListApps
2973#[derive(Debug, PartialEq)]
2974pub enum ListAppsError {
2975    /// <p>An internal error occurred.</p>
2976    InternalError(String),
2977    /// <p>A specified parameter is not valid.</p>
2978    InvalidParameter(String),
2979    /// <p>A required parameter is missing.</p>
2980    MissingRequiredParameter(String),
2981    /// <p>This operation is not allowed.</p>
2982    OperationNotPermitted(String),
2983    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
2984    UnauthorizedOperation(String),
2985}
2986
2987impl ListAppsError {
2988    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListAppsError> {
2989        if let Some(err) = proto::json::Error::parse(&res) {
2990            match err.typ.as_str() {
2991                "InternalError" => {
2992                    return RusotoError::Service(ListAppsError::InternalError(err.msg))
2993                }
2994                "InvalidParameterException" => {
2995                    return RusotoError::Service(ListAppsError::InvalidParameter(err.msg))
2996                }
2997                "MissingRequiredParameterException" => {
2998                    return RusotoError::Service(ListAppsError::MissingRequiredParameter(err.msg))
2999                }
3000                "OperationNotPermittedException" => {
3001                    return RusotoError::Service(ListAppsError::OperationNotPermitted(err.msg))
3002                }
3003                "UnauthorizedOperationException" => {
3004                    return RusotoError::Service(ListAppsError::UnauthorizedOperation(err.msg))
3005                }
3006                "ValidationException" => return RusotoError::Validation(err.msg),
3007                _ => {}
3008            }
3009        }
3010        RusotoError::Unknown(res)
3011    }
3012}
3013impl fmt::Display for ListAppsError {
3014    #[allow(unused_variables)]
3015    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3016        match *self {
3017            ListAppsError::InternalError(ref cause) => write!(f, "{}", cause),
3018            ListAppsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3019            ListAppsError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
3020            ListAppsError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
3021            ListAppsError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
3022        }
3023    }
3024}
3025impl Error for ListAppsError {}
3026/// Errors returned by NotifyAppValidationOutput
3027#[derive(Debug, PartialEq)]
3028pub enum NotifyAppValidationOutputError {
3029    /// <p>An internal error occurred.</p>
3030    InternalError(String),
3031    /// <p>A specified parameter is not valid.</p>
3032    InvalidParameter(String),
3033    /// <p>A required parameter is missing.</p>
3034    MissingRequiredParameter(String),
3035    /// <p>This operation is not allowed.</p>
3036    OperationNotPermitted(String),
3037    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
3038    UnauthorizedOperation(String),
3039}
3040
3041impl NotifyAppValidationOutputError {
3042    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<NotifyAppValidationOutputError> {
3043        if let Some(err) = proto::json::Error::parse(&res) {
3044            match err.typ.as_str() {
3045                "InternalError" => {
3046                    return RusotoError::Service(NotifyAppValidationOutputError::InternalError(
3047                        err.msg,
3048                    ))
3049                }
3050                "InvalidParameterException" => {
3051                    return RusotoError::Service(NotifyAppValidationOutputError::InvalidParameter(
3052                        err.msg,
3053                    ))
3054                }
3055                "MissingRequiredParameterException" => {
3056                    return RusotoError::Service(
3057                        NotifyAppValidationOutputError::MissingRequiredParameter(err.msg),
3058                    )
3059                }
3060                "OperationNotPermittedException" => {
3061                    return RusotoError::Service(
3062                        NotifyAppValidationOutputError::OperationNotPermitted(err.msg),
3063                    )
3064                }
3065                "UnauthorizedOperationException" => {
3066                    return RusotoError::Service(
3067                        NotifyAppValidationOutputError::UnauthorizedOperation(err.msg),
3068                    )
3069                }
3070                "ValidationException" => return RusotoError::Validation(err.msg),
3071                _ => {}
3072            }
3073        }
3074        RusotoError::Unknown(res)
3075    }
3076}
3077impl fmt::Display for NotifyAppValidationOutputError {
3078    #[allow(unused_variables)]
3079    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3080        match *self {
3081            NotifyAppValidationOutputError::InternalError(ref cause) => write!(f, "{}", cause),
3082            NotifyAppValidationOutputError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3083            NotifyAppValidationOutputError::MissingRequiredParameter(ref cause) => {
3084                write!(f, "{}", cause)
3085            }
3086            NotifyAppValidationOutputError::OperationNotPermitted(ref cause) => {
3087                write!(f, "{}", cause)
3088            }
3089            NotifyAppValidationOutputError::UnauthorizedOperation(ref cause) => {
3090                write!(f, "{}", cause)
3091            }
3092        }
3093    }
3094}
3095impl Error for NotifyAppValidationOutputError {}
3096/// Errors returned by PutAppLaunchConfiguration
3097#[derive(Debug, PartialEq)]
3098pub enum PutAppLaunchConfigurationError {
3099    /// <p>An internal error occurred.</p>
3100    InternalError(String),
3101    /// <p>A specified parameter is not valid.</p>
3102    InvalidParameter(String),
3103    /// <p>A required parameter is missing.</p>
3104    MissingRequiredParameter(String),
3105    /// <p>This operation is not allowed.</p>
3106    OperationNotPermitted(String),
3107    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
3108    UnauthorizedOperation(String),
3109}
3110
3111impl PutAppLaunchConfigurationError {
3112    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutAppLaunchConfigurationError> {
3113        if let Some(err) = proto::json::Error::parse(&res) {
3114            match err.typ.as_str() {
3115                "InternalError" => {
3116                    return RusotoError::Service(PutAppLaunchConfigurationError::InternalError(
3117                        err.msg,
3118                    ))
3119                }
3120                "InvalidParameterException" => {
3121                    return RusotoError::Service(PutAppLaunchConfigurationError::InvalidParameter(
3122                        err.msg,
3123                    ))
3124                }
3125                "MissingRequiredParameterException" => {
3126                    return RusotoError::Service(
3127                        PutAppLaunchConfigurationError::MissingRequiredParameter(err.msg),
3128                    )
3129                }
3130                "OperationNotPermittedException" => {
3131                    return RusotoError::Service(
3132                        PutAppLaunchConfigurationError::OperationNotPermitted(err.msg),
3133                    )
3134                }
3135                "UnauthorizedOperationException" => {
3136                    return RusotoError::Service(
3137                        PutAppLaunchConfigurationError::UnauthorizedOperation(err.msg),
3138                    )
3139                }
3140                "ValidationException" => return RusotoError::Validation(err.msg),
3141                _ => {}
3142            }
3143        }
3144        RusotoError::Unknown(res)
3145    }
3146}
3147impl fmt::Display for PutAppLaunchConfigurationError {
3148    #[allow(unused_variables)]
3149    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3150        match *self {
3151            PutAppLaunchConfigurationError::InternalError(ref cause) => write!(f, "{}", cause),
3152            PutAppLaunchConfigurationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3153            PutAppLaunchConfigurationError::MissingRequiredParameter(ref cause) => {
3154                write!(f, "{}", cause)
3155            }
3156            PutAppLaunchConfigurationError::OperationNotPermitted(ref cause) => {
3157                write!(f, "{}", cause)
3158            }
3159            PutAppLaunchConfigurationError::UnauthorizedOperation(ref cause) => {
3160                write!(f, "{}", cause)
3161            }
3162        }
3163    }
3164}
3165impl Error for PutAppLaunchConfigurationError {}
3166/// Errors returned by PutAppReplicationConfiguration
3167#[derive(Debug, PartialEq)]
3168pub enum PutAppReplicationConfigurationError {
3169    /// <p>An internal error occurred.</p>
3170    InternalError(String),
3171    /// <p>A specified parameter is not valid.</p>
3172    InvalidParameter(String),
3173    /// <p>A required parameter is missing.</p>
3174    MissingRequiredParameter(String),
3175    /// <p>This operation is not allowed.</p>
3176    OperationNotPermitted(String),
3177    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
3178    UnauthorizedOperation(String),
3179}
3180
3181impl PutAppReplicationConfigurationError {
3182    pub fn from_response(
3183        res: BufferedHttpResponse,
3184    ) -> RusotoError<PutAppReplicationConfigurationError> {
3185        if let Some(err) = proto::json::Error::parse(&res) {
3186            match err.typ.as_str() {
3187                "InternalError" => {
3188                    return RusotoError::Service(
3189                        PutAppReplicationConfigurationError::InternalError(err.msg),
3190                    )
3191                }
3192                "InvalidParameterException" => {
3193                    return RusotoError::Service(
3194                        PutAppReplicationConfigurationError::InvalidParameter(err.msg),
3195                    )
3196                }
3197                "MissingRequiredParameterException" => {
3198                    return RusotoError::Service(
3199                        PutAppReplicationConfigurationError::MissingRequiredParameter(err.msg),
3200                    )
3201                }
3202                "OperationNotPermittedException" => {
3203                    return RusotoError::Service(
3204                        PutAppReplicationConfigurationError::OperationNotPermitted(err.msg),
3205                    )
3206                }
3207                "UnauthorizedOperationException" => {
3208                    return RusotoError::Service(
3209                        PutAppReplicationConfigurationError::UnauthorizedOperation(err.msg),
3210                    )
3211                }
3212                "ValidationException" => return RusotoError::Validation(err.msg),
3213                _ => {}
3214            }
3215        }
3216        RusotoError::Unknown(res)
3217    }
3218}
3219impl fmt::Display for PutAppReplicationConfigurationError {
3220    #[allow(unused_variables)]
3221    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3222        match *self {
3223            PutAppReplicationConfigurationError::InternalError(ref cause) => write!(f, "{}", cause),
3224            PutAppReplicationConfigurationError::InvalidParameter(ref cause) => {
3225                write!(f, "{}", cause)
3226            }
3227            PutAppReplicationConfigurationError::MissingRequiredParameter(ref cause) => {
3228                write!(f, "{}", cause)
3229            }
3230            PutAppReplicationConfigurationError::OperationNotPermitted(ref cause) => {
3231                write!(f, "{}", cause)
3232            }
3233            PutAppReplicationConfigurationError::UnauthorizedOperation(ref cause) => {
3234                write!(f, "{}", cause)
3235            }
3236        }
3237    }
3238}
3239impl Error for PutAppReplicationConfigurationError {}
3240/// Errors returned by PutAppValidationConfiguration
3241#[derive(Debug, PartialEq)]
3242pub enum PutAppValidationConfigurationError {
3243    /// <p>An internal error occurred.</p>
3244    InternalError(String),
3245    /// <p>A specified parameter is not valid.</p>
3246    InvalidParameter(String),
3247    /// <p>A required parameter is missing.</p>
3248    MissingRequiredParameter(String),
3249    /// <p>This operation is not allowed.</p>
3250    OperationNotPermitted(String),
3251    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
3252    UnauthorizedOperation(String),
3253}
3254
3255impl PutAppValidationConfigurationError {
3256    pub fn from_response(
3257        res: BufferedHttpResponse,
3258    ) -> RusotoError<PutAppValidationConfigurationError> {
3259        if let Some(err) = proto::json::Error::parse(&res) {
3260            match err.typ.as_str() {
3261                "InternalError" => {
3262                    return RusotoError::Service(PutAppValidationConfigurationError::InternalError(
3263                        err.msg,
3264                    ))
3265                }
3266                "InvalidParameterException" => {
3267                    return RusotoError::Service(
3268                        PutAppValidationConfigurationError::InvalidParameter(err.msg),
3269                    )
3270                }
3271                "MissingRequiredParameterException" => {
3272                    return RusotoError::Service(
3273                        PutAppValidationConfigurationError::MissingRequiredParameter(err.msg),
3274                    )
3275                }
3276                "OperationNotPermittedException" => {
3277                    return RusotoError::Service(
3278                        PutAppValidationConfigurationError::OperationNotPermitted(err.msg),
3279                    )
3280                }
3281                "UnauthorizedOperationException" => {
3282                    return RusotoError::Service(
3283                        PutAppValidationConfigurationError::UnauthorizedOperation(err.msg),
3284                    )
3285                }
3286                "ValidationException" => return RusotoError::Validation(err.msg),
3287                _ => {}
3288            }
3289        }
3290        RusotoError::Unknown(res)
3291    }
3292}
3293impl fmt::Display for PutAppValidationConfigurationError {
3294    #[allow(unused_variables)]
3295    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3296        match *self {
3297            PutAppValidationConfigurationError::InternalError(ref cause) => write!(f, "{}", cause),
3298            PutAppValidationConfigurationError::InvalidParameter(ref cause) => {
3299                write!(f, "{}", cause)
3300            }
3301            PutAppValidationConfigurationError::MissingRequiredParameter(ref cause) => {
3302                write!(f, "{}", cause)
3303            }
3304            PutAppValidationConfigurationError::OperationNotPermitted(ref cause) => {
3305                write!(f, "{}", cause)
3306            }
3307            PutAppValidationConfigurationError::UnauthorizedOperation(ref cause) => {
3308                write!(f, "{}", cause)
3309            }
3310        }
3311    }
3312}
3313impl Error for PutAppValidationConfigurationError {}
3314/// Errors returned by StartAppReplication
3315#[derive(Debug, PartialEq)]
3316pub enum StartAppReplicationError {
3317    /// <p>An internal error occurred.</p>
3318    InternalError(String),
3319    /// <p>A specified parameter is not valid.</p>
3320    InvalidParameter(String),
3321    /// <p>A required parameter is missing.</p>
3322    MissingRequiredParameter(String),
3323    /// <p>This operation is not allowed.</p>
3324    OperationNotPermitted(String),
3325    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
3326    UnauthorizedOperation(String),
3327}
3328
3329impl StartAppReplicationError {
3330    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartAppReplicationError> {
3331        if let Some(err) = proto::json::Error::parse(&res) {
3332            match err.typ.as_str() {
3333                "InternalError" => {
3334                    return RusotoError::Service(StartAppReplicationError::InternalError(err.msg))
3335                }
3336                "InvalidParameterException" => {
3337                    return RusotoError::Service(StartAppReplicationError::InvalidParameter(
3338                        err.msg,
3339                    ))
3340                }
3341                "MissingRequiredParameterException" => {
3342                    return RusotoError::Service(
3343                        StartAppReplicationError::MissingRequiredParameter(err.msg),
3344                    )
3345                }
3346                "OperationNotPermittedException" => {
3347                    return RusotoError::Service(StartAppReplicationError::OperationNotPermitted(
3348                        err.msg,
3349                    ))
3350                }
3351                "UnauthorizedOperationException" => {
3352                    return RusotoError::Service(StartAppReplicationError::UnauthorizedOperation(
3353                        err.msg,
3354                    ))
3355                }
3356                "ValidationException" => return RusotoError::Validation(err.msg),
3357                _ => {}
3358            }
3359        }
3360        RusotoError::Unknown(res)
3361    }
3362}
3363impl fmt::Display for StartAppReplicationError {
3364    #[allow(unused_variables)]
3365    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3366        match *self {
3367            StartAppReplicationError::InternalError(ref cause) => write!(f, "{}", cause),
3368            StartAppReplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3369            StartAppReplicationError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
3370            StartAppReplicationError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
3371            StartAppReplicationError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
3372        }
3373    }
3374}
3375impl Error for StartAppReplicationError {}
3376/// Errors returned by StartOnDemandAppReplication
3377#[derive(Debug, PartialEq)]
3378pub enum StartOnDemandAppReplicationError {
3379    /// <p>An internal error occurred.</p>
3380    InternalError(String),
3381    /// <p>A specified parameter is not valid.</p>
3382    InvalidParameter(String),
3383    /// <p>A required parameter is missing.</p>
3384    MissingRequiredParameter(String),
3385    /// <p>This operation is not allowed.</p>
3386    OperationNotPermitted(String),
3387    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
3388    UnauthorizedOperation(String),
3389}
3390
3391impl StartOnDemandAppReplicationError {
3392    pub fn from_response(
3393        res: BufferedHttpResponse,
3394    ) -> RusotoError<StartOnDemandAppReplicationError> {
3395        if let Some(err) = proto::json::Error::parse(&res) {
3396            match err.typ.as_str() {
3397                "InternalError" => {
3398                    return RusotoError::Service(StartOnDemandAppReplicationError::InternalError(
3399                        err.msg,
3400                    ))
3401                }
3402                "InvalidParameterException" => {
3403                    return RusotoError::Service(
3404                        StartOnDemandAppReplicationError::InvalidParameter(err.msg),
3405                    )
3406                }
3407                "MissingRequiredParameterException" => {
3408                    return RusotoError::Service(
3409                        StartOnDemandAppReplicationError::MissingRequiredParameter(err.msg),
3410                    )
3411                }
3412                "OperationNotPermittedException" => {
3413                    return RusotoError::Service(
3414                        StartOnDemandAppReplicationError::OperationNotPermitted(err.msg),
3415                    )
3416                }
3417                "UnauthorizedOperationException" => {
3418                    return RusotoError::Service(
3419                        StartOnDemandAppReplicationError::UnauthorizedOperation(err.msg),
3420                    )
3421                }
3422                "ValidationException" => return RusotoError::Validation(err.msg),
3423                _ => {}
3424            }
3425        }
3426        RusotoError::Unknown(res)
3427    }
3428}
3429impl fmt::Display for StartOnDemandAppReplicationError {
3430    #[allow(unused_variables)]
3431    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3432        match *self {
3433            StartOnDemandAppReplicationError::InternalError(ref cause) => write!(f, "{}", cause),
3434            StartOnDemandAppReplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3435            StartOnDemandAppReplicationError::MissingRequiredParameter(ref cause) => {
3436                write!(f, "{}", cause)
3437            }
3438            StartOnDemandAppReplicationError::OperationNotPermitted(ref cause) => {
3439                write!(f, "{}", cause)
3440            }
3441            StartOnDemandAppReplicationError::UnauthorizedOperation(ref cause) => {
3442                write!(f, "{}", cause)
3443            }
3444        }
3445    }
3446}
3447impl Error for StartOnDemandAppReplicationError {}
3448/// Errors returned by StartOnDemandReplicationRun
3449#[derive(Debug, PartialEq)]
3450pub enum StartOnDemandReplicationRunError {
3451    /// <p>The user has the required permissions, so the request would have succeeded, but a dry run was performed.</p>
3452    DryRunOperation(String),
3453    /// <p>A specified parameter is not valid.</p>
3454    InvalidParameter(String),
3455    /// <p>A required parameter is missing.</p>
3456    MissingRequiredParameter(String),
3457    /// <p>This operation is not allowed.</p>
3458    OperationNotPermitted(String),
3459    /// <p>You have exceeded the number of on-demand replication runs you can request in a 24-hour period.</p>
3460    ReplicationRunLimitExceeded(String),
3461    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
3462    UnauthorizedOperation(String),
3463}
3464
3465impl StartOnDemandReplicationRunError {
3466    pub fn from_response(
3467        res: BufferedHttpResponse,
3468    ) -> RusotoError<StartOnDemandReplicationRunError> {
3469        if let Some(err) = proto::json::Error::parse(&res) {
3470            match err.typ.as_str() {
3471                "DryRunOperationException" => {
3472                    return RusotoError::Service(StartOnDemandReplicationRunError::DryRunOperation(
3473                        err.msg,
3474                    ))
3475                }
3476                "InvalidParameterException" => {
3477                    return RusotoError::Service(
3478                        StartOnDemandReplicationRunError::InvalidParameter(err.msg),
3479                    )
3480                }
3481                "MissingRequiredParameterException" => {
3482                    return RusotoError::Service(
3483                        StartOnDemandReplicationRunError::MissingRequiredParameter(err.msg),
3484                    )
3485                }
3486                "OperationNotPermittedException" => {
3487                    return RusotoError::Service(
3488                        StartOnDemandReplicationRunError::OperationNotPermitted(err.msg),
3489                    )
3490                }
3491                "ReplicationRunLimitExceededException" => {
3492                    return RusotoError::Service(
3493                        StartOnDemandReplicationRunError::ReplicationRunLimitExceeded(err.msg),
3494                    )
3495                }
3496                "UnauthorizedOperationException" => {
3497                    return RusotoError::Service(
3498                        StartOnDemandReplicationRunError::UnauthorizedOperation(err.msg),
3499                    )
3500                }
3501                "ValidationException" => return RusotoError::Validation(err.msg),
3502                _ => {}
3503            }
3504        }
3505        RusotoError::Unknown(res)
3506    }
3507}
3508impl fmt::Display for StartOnDemandReplicationRunError {
3509    #[allow(unused_variables)]
3510    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3511        match *self {
3512            StartOnDemandReplicationRunError::DryRunOperation(ref cause) => write!(f, "{}", cause),
3513            StartOnDemandReplicationRunError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3514            StartOnDemandReplicationRunError::MissingRequiredParameter(ref cause) => {
3515                write!(f, "{}", cause)
3516            }
3517            StartOnDemandReplicationRunError::OperationNotPermitted(ref cause) => {
3518                write!(f, "{}", cause)
3519            }
3520            StartOnDemandReplicationRunError::ReplicationRunLimitExceeded(ref cause) => {
3521                write!(f, "{}", cause)
3522            }
3523            StartOnDemandReplicationRunError::UnauthorizedOperation(ref cause) => {
3524                write!(f, "{}", cause)
3525            }
3526        }
3527    }
3528}
3529impl Error for StartOnDemandReplicationRunError {}
3530/// Errors returned by StopAppReplication
3531#[derive(Debug, PartialEq)]
3532pub enum StopAppReplicationError {
3533    /// <p>An internal error occurred.</p>
3534    InternalError(String),
3535    /// <p>A specified parameter is not valid.</p>
3536    InvalidParameter(String),
3537    /// <p>A required parameter is missing.</p>
3538    MissingRequiredParameter(String),
3539    /// <p>This operation is not allowed.</p>
3540    OperationNotPermitted(String),
3541    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
3542    UnauthorizedOperation(String),
3543}
3544
3545impl StopAppReplicationError {
3546    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopAppReplicationError> {
3547        if let Some(err) = proto::json::Error::parse(&res) {
3548            match err.typ.as_str() {
3549                "InternalError" => {
3550                    return RusotoError::Service(StopAppReplicationError::InternalError(err.msg))
3551                }
3552                "InvalidParameterException" => {
3553                    return RusotoError::Service(StopAppReplicationError::InvalidParameter(err.msg))
3554                }
3555                "MissingRequiredParameterException" => {
3556                    return RusotoError::Service(StopAppReplicationError::MissingRequiredParameter(
3557                        err.msg,
3558                    ))
3559                }
3560                "OperationNotPermittedException" => {
3561                    return RusotoError::Service(StopAppReplicationError::OperationNotPermitted(
3562                        err.msg,
3563                    ))
3564                }
3565                "UnauthorizedOperationException" => {
3566                    return RusotoError::Service(StopAppReplicationError::UnauthorizedOperation(
3567                        err.msg,
3568                    ))
3569                }
3570                "ValidationException" => return RusotoError::Validation(err.msg),
3571                _ => {}
3572            }
3573        }
3574        RusotoError::Unknown(res)
3575    }
3576}
3577impl fmt::Display for StopAppReplicationError {
3578    #[allow(unused_variables)]
3579    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3580        match *self {
3581            StopAppReplicationError::InternalError(ref cause) => write!(f, "{}", cause),
3582            StopAppReplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3583            StopAppReplicationError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
3584            StopAppReplicationError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
3585            StopAppReplicationError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
3586        }
3587    }
3588}
3589impl Error for StopAppReplicationError {}
3590/// Errors returned by TerminateApp
3591#[derive(Debug, PartialEq)]
3592pub enum TerminateAppError {
3593    /// <p>An internal error occurred.</p>
3594    InternalError(String),
3595    /// <p>A specified parameter is not valid.</p>
3596    InvalidParameter(String),
3597    /// <p>A required parameter is missing.</p>
3598    MissingRequiredParameter(String),
3599    /// <p>This operation is not allowed.</p>
3600    OperationNotPermitted(String),
3601    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
3602    UnauthorizedOperation(String),
3603}
3604
3605impl TerminateAppError {
3606    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TerminateAppError> {
3607        if let Some(err) = proto::json::Error::parse(&res) {
3608            match err.typ.as_str() {
3609                "InternalError" => {
3610                    return RusotoError::Service(TerminateAppError::InternalError(err.msg))
3611                }
3612                "InvalidParameterException" => {
3613                    return RusotoError::Service(TerminateAppError::InvalidParameter(err.msg))
3614                }
3615                "MissingRequiredParameterException" => {
3616                    return RusotoError::Service(TerminateAppError::MissingRequiredParameter(
3617                        err.msg,
3618                    ))
3619                }
3620                "OperationNotPermittedException" => {
3621                    return RusotoError::Service(TerminateAppError::OperationNotPermitted(err.msg))
3622                }
3623                "UnauthorizedOperationException" => {
3624                    return RusotoError::Service(TerminateAppError::UnauthorizedOperation(err.msg))
3625                }
3626                "ValidationException" => return RusotoError::Validation(err.msg),
3627                _ => {}
3628            }
3629        }
3630        RusotoError::Unknown(res)
3631    }
3632}
3633impl fmt::Display for TerminateAppError {
3634    #[allow(unused_variables)]
3635    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3636        match *self {
3637            TerminateAppError::InternalError(ref cause) => write!(f, "{}", cause),
3638            TerminateAppError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3639            TerminateAppError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
3640            TerminateAppError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
3641            TerminateAppError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
3642        }
3643    }
3644}
3645impl Error for TerminateAppError {}
3646/// Errors returned by UpdateApp
3647#[derive(Debug, PartialEq)]
3648pub enum UpdateAppError {
3649    /// <p>An internal error occurred.</p>
3650    InternalError(String),
3651    /// <p>A specified parameter is not valid.</p>
3652    InvalidParameter(String),
3653    /// <p>A required parameter is missing.</p>
3654    MissingRequiredParameter(String),
3655    /// <p>This operation is not allowed.</p>
3656    OperationNotPermitted(String),
3657    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
3658    UnauthorizedOperation(String),
3659}
3660
3661impl UpdateAppError {
3662    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateAppError> {
3663        if let Some(err) = proto::json::Error::parse(&res) {
3664            match err.typ.as_str() {
3665                "InternalError" => {
3666                    return RusotoError::Service(UpdateAppError::InternalError(err.msg))
3667                }
3668                "InvalidParameterException" => {
3669                    return RusotoError::Service(UpdateAppError::InvalidParameter(err.msg))
3670                }
3671                "MissingRequiredParameterException" => {
3672                    return RusotoError::Service(UpdateAppError::MissingRequiredParameter(err.msg))
3673                }
3674                "OperationNotPermittedException" => {
3675                    return RusotoError::Service(UpdateAppError::OperationNotPermitted(err.msg))
3676                }
3677                "UnauthorizedOperationException" => {
3678                    return RusotoError::Service(UpdateAppError::UnauthorizedOperation(err.msg))
3679                }
3680                "ValidationException" => return RusotoError::Validation(err.msg),
3681                _ => {}
3682            }
3683        }
3684        RusotoError::Unknown(res)
3685    }
3686}
3687impl fmt::Display for UpdateAppError {
3688    #[allow(unused_variables)]
3689    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3690        match *self {
3691            UpdateAppError::InternalError(ref cause) => write!(f, "{}", cause),
3692            UpdateAppError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3693            UpdateAppError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
3694            UpdateAppError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
3695            UpdateAppError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
3696        }
3697    }
3698}
3699impl Error for UpdateAppError {}
3700/// Errors returned by UpdateReplicationJob
3701#[derive(Debug, PartialEq)]
3702pub enum UpdateReplicationJobError {
3703    /// <p>An internal error occurred.</p>
3704    InternalError(String),
3705    /// <p>A specified parameter is not valid.</p>
3706    InvalidParameter(String),
3707    /// <p>A required parameter is missing.</p>
3708    MissingRequiredParameter(String),
3709    /// <p>This operation is not allowed.</p>
3710    OperationNotPermitted(String),
3711    /// <p>The specified replication job does not exist.</p>
3712    ReplicationJobNotFound(String),
3713    /// <p>The specified server cannot be replicated.</p>
3714    ServerCannotBeReplicated(String),
3715    /// <p>The service is temporarily unavailable.</p>
3716    TemporarilyUnavailable(String),
3717    /// <p>You lack permissions needed to perform this operation. Check your IAM policies, and ensure that you are using the correct access keys.</p>
3718    UnauthorizedOperation(String),
3719}
3720
3721impl UpdateReplicationJobError {
3722    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateReplicationJobError> {
3723        if let Some(err) = proto::json::Error::parse(&res) {
3724            match err.typ.as_str() {
3725                "InternalError" => {
3726                    return RusotoError::Service(UpdateReplicationJobError::InternalError(err.msg))
3727                }
3728                "InvalidParameterException" => {
3729                    return RusotoError::Service(UpdateReplicationJobError::InvalidParameter(
3730                        err.msg,
3731                    ))
3732                }
3733                "MissingRequiredParameterException" => {
3734                    return RusotoError::Service(
3735                        UpdateReplicationJobError::MissingRequiredParameter(err.msg),
3736                    )
3737                }
3738                "OperationNotPermittedException" => {
3739                    return RusotoError::Service(UpdateReplicationJobError::OperationNotPermitted(
3740                        err.msg,
3741                    ))
3742                }
3743                "ReplicationJobNotFoundException" => {
3744                    return RusotoError::Service(UpdateReplicationJobError::ReplicationJobNotFound(
3745                        err.msg,
3746                    ))
3747                }
3748                "ServerCannotBeReplicatedException" => {
3749                    return RusotoError::Service(
3750                        UpdateReplicationJobError::ServerCannotBeReplicated(err.msg),
3751                    )
3752                }
3753                "TemporarilyUnavailableException" => {
3754                    return RusotoError::Service(UpdateReplicationJobError::TemporarilyUnavailable(
3755                        err.msg,
3756                    ))
3757                }
3758                "UnauthorizedOperationException" => {
3759                    return RusotoError::Service(UpdateReplicationJobError::UnauthorizedOperation(
3760                        err.msg,
3761                    ))
3762                }
3763                "ValidationException" => return RusotoError::Validation(err.msg),
3764                _ => {}
3765            }
3766        }
3767        RusotoError::Unknown(res)
3768    }
3769}
3770impl fmt::Display for UpdateReplicationJobError {
3771    #[allow(unused_variables)]
3772    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3773        match *self {
3774            UpdateReplicationJobError::InternalError(ref cause) => write!(f, "{}", cause),
3775            UpdateReplicationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
3776            UpdateReplicationJobError::MissingRequiredParameter(ref cause) => {
3777                write!(f, "{}", cause)
3778            }
3779            UpdateReplicationJobError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
3780            UpdateReplicationJobError::ReplicationJobNotFound(ref cause) => write!(f, "{}", cause),
3781            UpdateReplicationJobError::ServerCannotBeReplicated(ref cause) => {
3782                write!(f, "{}", cause)
3783            }
3784            UpdateReplicationJobError::TemporarilyUnavailable(ref cause) => write!(f, "{}", cause),
3785            UpdateReplicationJobError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
3786        }
3787    }
3788}
3789impl Error for UpdateReplicationJobError {}
3790/// Trait representing the capabilities of the SMS API. SMS clients implement this trait.
3791#[async_trait]
3792pub trait ServerMigrationService {
3793    /// <p>Creates an application. An application consists of one or more server groups. Each server group contain one or more servers.</p>
3794    async fn create_app(
3795        &self,
3796        input: CreateAppRequest,
3797    ) -> Result<CreateAppResponse, RusotoError<CreateAppError>>;
3798
3799    /// <p>Creates a replication job. The replication job schedules periodic replication runs to replicate your server to AWS. Each replication run creates an Amazon Machine Image (AMI).</p>
3800    async fn create_replication_job(
3801        &self,
3802        input: CreateReplicationJobRequest,
3803    ) -> Result<CreateReplicationJobResponse, RusotoError<CreateReplicationJobError>>;
3804
3805    /// <p>Deletes the specified application. Optionally deletes the launched stack associated with the application and all AWS SMS replication jobs for servers in the application.</p>
3806    async fn delete_app(
3807        &self,
3808        input: DeleteAppRequest,
3809    ) -> Result<DeleteAppResponse, RusotoError<DeleteAppError>>;
3810
3811    /// <p>Deletes the launch configuration for the specified application.</p>
3812    async fn delete_app_launch_configuration(
3813        &self,
3814        input: DeleteAppLaunchConfigurationRequest,
3815    ) -> Result<DeleteAppLaunchConfigurationResponse, RusotoError<DeleteAppLaunchConfigurationError>>;
3816
3817    /// <p>Deletes the replication configuration for the specified application.</p>
3818    async fn delete_app_replication_configuration(
3819        &self,
3820        input: DeleteAppReplicationConfigurationRequest,
3821    ) -> Result<
3822        DeleteAppReplicationConfigurationResponse,
3823        RusotoError<DeleteAppReplicationConfigurationError>,
3824    >;
3825
3826    /// <p>Deletes the validation configuration for the specified application.</p>
3827    async fn delete_app_validation_configuration(
3828        &self,
3829        input: DeleteAppValidationConfigurationRequest,
3830    ) -> Result<
3831        DeleteAppValidationConfigurationResponse,
3832        RusotoError<DeleteAppValidationConfigurationError>,
3833    >;
3834
3835    /// <p>Deletes the specified replication job.</p> <p>After you delete a replication job, there are no further replication runs. AWS deletes the contents of the Amazon S3 bucket used to store AWS SMS artifacts. The AMIs created by the replication runs are not deleted.</p>
3836    async fn delete_replication_job(
3837        &self,
3838        input: DeleteReplicationJobRequest,
3839    ) -> Result<DeleteReplicationJobResponse, RusotoError<DeleteReplicationJobError>>;
3840
3841    /// <p>Deletes all servers from your server catalog.</p>
3842    async fn delete_server_catalog(
3843        &self,
3844    ) -> Result<DeleteServerCatalogResponse, RusotoError<DeleteServerCatalogError>>;
3845
3846    /// <p>Disassociates the specified connector from AWS SMS.</p> <p>After you disassociate a connector, it is no longer available to support replication jobs.</p>
3847    async fn disassociate_connector(
3848        &self,
3849        input: DisassociateConnectorRequest,
3850    ) -> Result<DisassociateConnectorResponse, RusotoError<DisassociateConnectorError>>;
3851
3852    /// <p>Generates a target change set for a currently launched stack and writes it to an Amazon S3 object in the customer’s Amazon S3 bucket.</p>
3853    async fn generate_change_set(
3854        &self,
3855        input: GenerateChangeSetRequest,
3856    ) -> Result<GenerateChangeSetResponse, RusotoError<GenerateChangeSetError>>;
3857
3858    /// <p>Generates an AWS CloudFormation template based on the current launch configuration and writes it to an Amazon S3 object in the customer’s Amazon S3 bucket.</p>
3859    async fn generate_template(
3860        &self,
3861        input: GenerateTemplateRequest,
3862    ) -> Result<GenerateTemplateResponse, RusotoError<GenerateTemplateError>>;
3863
3864    /// <p>Retrieve information about the specified application.</p>
3865    async fn get_app(
3866        &self,
3867        input: GetAppRequest,
3868    ) -> Result<GetAppResponse, RusotoError<GetAppError>>;
3869
3870    /// <p>Retrieves the application launch configuration associated with the specified application.</p>
3871    async fn get_app_launch_configuration(
3872        &self,
3873        input: GetAppLaunchConfigurationRequest,
3874    ) -> Result<GetAppLaunchConfigurationResponse, RusotoError<GetAppLaunchConfigurationError>>;
3875
3876    /// <p>Retrieves the application replication configuration associated with the specified application.</p>
3877    async fn get_app_replication_configuration(
3878        &self,
3879        input: GetAppReplicationConfigurationRequest,
3880    ) -> Result<
3881        GetAppReplicationConfigurationResponse,
3882        RusotoError<GetAppReplicationConfigurationError>,
3883    >;
3884
3885    /// <p>Retrieves information about a configuration for validating an application.</p>
3886    async fn get_app_validation_configuration(
3887        &self,
3888        input: GetAppValidationConfigurationRequest,
3889    ) -> Result<
3890        GetAppValidationConfigurationResponse,
3891        RusotoError<GetAppValidationConfigurationError>,
3892    >;
3893
3894    /// <p>Retrieves output from validating an application.</p>
3895    async fn get_app_validation_output(
3896        &self,
3897        input: GetAppValidationOutputRequest,
3898    ) -> Result<GetAppValidationOutputResponse, RusotoError<GetAppValidationOutputError>>;
3899
3900    /// <p>Describes the connectors registered with the AWS SMS.</p>
3901    async fn get_connectors(
3902        &self,
3903        input: GetConnectorsRequest,
3904    ) -> Result<GetConnectorsResponse, RusotoError<GetConnectorsError>>;
3905
3906    /// <p>Describes the specified replication job or all of your replication jobs.</p>
3907    async fn get_replication_jobs(
3908        &self,
3909        input: GetReplicationJobsRequest,
3910    ) -> Result<GetReplicationJobsResponse, RusotoError<GetReplicationJobsError>>;
3911
3912    /// <p>Describes the replication runs for the specified replication job.</p>
3913    async fn get_replication_runs(
3914        &self,
3915        input: GetReplicationRunsRequest,
3916    ) -> Result<GetReplicationRunsResponse, RusotoError<GetReplicationRunsError>>;
3917
3918    /// <p>Describes the servers in your server catalog.</p> <p>Before you can describe your servers, you must import them using <a>ImportServerCatalog</a>.</p>
3919    async fn get_servers(
3920        &self,
3921        input: GetServersRequest,
3922    ) -> Result<GetServersResponse, RusotoError<GetServersError>>;
3923
3924    /// <p>Allows application import from AWS Migration Hub.</p>
3925    async fn import_app_catalog(
3926        &self,
3927        input: ImportAppCatalogRequest,
3928    ) -> Result<ImportAppCatalogResponse, RusotoError<ImportAppCatalogError>>;
3929
3930    /// <p>Gathers a complete list of on-premises servers. Connectors must be installed and monitoring all servers to import.</p> <p>This call returns immediately, but might take additional time to retrieve all the servers.</p>
3931    async fn import_server_catalog(
3932        &self,
3933    ) -> Result<ImportServerCatalogResponse, RusotoError<ImportServerCatalogError>>;
3934
3935    /// <p>Launches the specified application as a stack in AWS CloudFormation.</p>
3936    async fn launch_app(
3937        &self,
3938        input: LaunchAppRequest,
3939    ) -> Result<LaunchAppResponse, RusotoError<LaunchAppError>>;
3940
3941    /// <p>Retrieves summaries for all applications.</p>
3942    async fn list_apps(
3943        &self,
3944        input: ListAppsRequest,
3945    ) -> Result<ListAppsResponse, RusotoError<ListAppsError>>;
3946
3947    /// <p>Provides information to AWS SMS about whether application validation is successful.</p>
3948    async fn notify_app_validation_output(
3949        &self,
3950        input: NotifyAppValidationOutputRequest,
3951    ) -> Result<NotifyAppValidationOutputResponse, RusotoError<NotifyAppValidationOutputError>>;
3952
3953    /// <p>Creates or updates the launch configuration for the specified application.</p>
3954    async fn put_app_launch_configuration(
3955        &self,
3956        input: PutAppLaunchConfigurationRequest,
3957    ) -> Result<PutAppLaunchConfigurationResponse, RusotoError<PutAppLaunchConfigurationError>>;
3958
3959    /// <p>Creates or updates the replication configuration for the specified application.</p>
3960    async fn put_app_replication_configuration(
3961        &self,
3962        input: PutAppReplicationConfigurationRequest,
3963    ) -> Result<
3964        PutAppReplicationConfigurationResponse,
3965        RusotoError<PutAppReplicationConfigurationError>,
3966    >;
3967
3968    /// <p>Creates or updates a validation configuration for the specified application.</p>
3969    async fn put_app_validation_configuration(
3970        &self,
3971        input: PutAppValidationConfigurationRequest,
3972    ) -> Result<
3973        PutAppValidationConfigurationResponse,
3974        RusotoError<PutAppValidationConfigurationError>,
3975    >;
3976
3977    /// <p>Starts replicating the specified application by creating replication jobs for each server in the application.</p>
3978    async fn start_app_replication(
3979        &self,
3980        input: StartAppReplicationRequest,
3981    ) -> Result<StartAppReplicationResponse, RusotoError<StartAppReplicationError>>;
3982
3983    /// <p>Starts an on-demand replication run for the specified application.</p>
3984    async fn start_on_demand_app_replication(
3985        &self,
3986        input: StartOnDemandAppReplicationRequest,
3987    ) -> Result<StartOnDemandAppReplicationResponse, RusotoError<StartOnDemandAppReplicationError>>;
3988
3989    /// <p>Starts an on-demand replication run for the specified replication job. This replication run starts immediately. This replication run is in addition to the ones already scheduled.</p> <p>There is a limit on the number of on-demand replications runs that you can request in a 24-hour period.</p>
3990    async fn start_on_demand_replication_run(
3991        &self,
3992        input: StartOnDemandReplicationRunRequest,
3993    ) -> Result<StartOnDemandReplicationRunResponse, RusotoError<StartOnDemandReplicationRunError>>;
3994
3995    /// <p>Stops replicating the specified application by deleting the replication job for each server in the application.</p>
3996    async fn stop_app_replication(
3997        &self,
3998        input: StopAppReplicationRequest,
3999    ) -> Result<StopAppReplicationResponse, RusotoError<StopAppReplicationError>>;
4000
4001    /// <p>Terminates the stack for the specified application.</p>
4002    async fn terminate_app(
4003        &self,
4004        input: TerminateAppRequest,
4005    ) -> Result<TerminateAppResponse, RusotoError<TerminateAppError>>;
4006
4007    /// <p>Updates the specified application.</p>
4008    async fn update_app(
4009        &self,
4010        input: UpdateAppRequest,
4011    ) -> Result<UpdateAppResponse, RusotoError<UpdateAppError>>;
4012
4013    /// <p>Updates the specified settings for the specified replication job.</p>
4014    async fn update_replication_job(
4015        &self,
4016        input: UpdateReplicationJobRequest,
4017    ) -> Result<UpdateReplicationJobResponse, RusotoError<UpdateReplicationJobError>>;
4018}
4019/// A client for the SMS API.
4020#[derive(Clone)]
4021pub struct ServerMigrationServiceClient {
4022    client: Client,
4023    region: region::Region,
4024}
4025
4026impl ServerMigrationServiceClient {
4027    /// Creates a client backed by the default tokio event loop.
4028    ///
4029    /// The client will use the default credentials provider and tls client.
4030    pub fn new(region: region::Region) -> ServerMigrationServiceClient {
4031        ServerMigrationServiceClient {
4032            client: Client::shared(),
4033            region,
4034        }
4035    }
4036
4037    pub fn new_with<P, D>(
4038        request_dispatcher: D,
4039        credentials_provider: P,
4040        region: region::Region,
4041    ) -> ServerMigrationServiceClient
4042    where
4043        P: ProvideAwsCredentials + Send + Sync + 'static,
4044        D: DispatchSignedRequest + Send + Sync + 'static,
4045    {
4046        ServerMigrationServiceClient {
4047            client: Client::new_with(credentials_provider, request_dispatcher),
4048            region,
4049        }
4050    }
4051
4052    pub fn new_with_client(client: Client, region: region::Region) -> ServerMigrationServiceClient {
4053        ServerMigrationServiceClient { client, region }
4054    }
4055}
4056
4057#[async_trait]
4058impl ServerMigrationService for ServerMigrationServiceClient {
4059    /// <p>Creates an application. An application consists of one or more server groups. Each server group contain one or more servers.</p>
4060    async fn create_app(
4061        &self,
4062        input: CreateAppRequest,
4063    ) -> Result<CreateAppResponse, RusotoError<CreateAppError>> {
4064        let mut request = self.new_signed_request("POST", "/");
4065        request.add_header(
4066            "x-amz-target",
4067            "AWSServerMigrationService_V2016_10_24.CreateApp",
4068        );
4069        let encoded = serde_json::to_string(&input).unwrap();
4070        request.set_payload(Some(encoded));
4071
4072        let response = self
4073            .sign_and_dispatch(request, CreateAppError::from_response)
4074            .await?;
4075        let mut response = response;
4076        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4077        proto::json::ResponsePayload::new(&response).deserialize::<CreateAppResponse, _>()
4078    }
4079
4080    /// <p>Creates a replication job. The replication job schedules periodic replication runs to replicate your server to AWS. Each replication run creates an Amazon Machine Image (AMI).</p>
4081    async fn create_replication_job(
4082        &self,
4083        input: CreateReplicationJobRequest,
4084    ) -> Result<CreateReplicationJobResponse, RusotoError<CreateReplicationJobError>> {
4085        let mut request = self.new_signed_request("POST", "/");
4086        request.add_header(
4087            "x-amz-target",
4088            "AWSServerMigrationService_V2016_10_24.CreateReplicationJob",
4089        );
4090        let encoded = serde_json::to_string(&input).unwrap();
4091        request.set_payload(Some(encoded));
4092
4093        let response = self
4094            .sign_and_dispatch(request, CreateReplicationJobError::from_response)
4095            .await?;
4096        let mut response = response;
4097        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4098        proto::json::ResponsePayload::new(&response)
4099            .deserialize::<CreateReplicationJobResponse, _>()
4100    }
4101
4102    /// <p>Deletes the specified application. Optionally deletes the launched stack associated with the application and all AWS SMS replication jobs for servers in the application.</p>
4103    async fn delete_app(
4104        &self,
4105        input: DeleteAppRequest,
4106    ) -> Result<DeleteAppResponse, RusotoError<DeleteAppError>> {
4107        let mut request = self.new_signed_request("POST", "/");
4108        request.add_header(
4109            "x-amz-target",
4110            "AWSServerMigrationService_V2016_10_24.DeleteApp",
4111        );
4112        let encoded = serde_json::to_string(&input).unwrap();
4113        request.set_payload(Some(encoded));
4114
4115        let response = self
4116            .sign_and_dispatch(request, DeleteAppError::from_response)
4117            .await?;
4118        let mut response = response;
4119        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4120        proto::json::ResponsePayload::new(&response).deserialize::<DeleteAppResponse, _>()
4121    }
4122
4123    /// <p>Deletes the launch configuration for the specified application.</p>
4124    async fn delete_app_launch_configuration(
4125        &self,
4126        input: DeleteAppLaunchConfigurationRequest,
4127    ) -> Result<DeleteAppLaunchConfigurationResponse, RusotoError<DeleteAppLaunchConfigurationError>>
4128    {
4129        let mut request = self.new_signed_request("POST", "/");
4130        request.add_header(
4131            "x-amz-target",
4132            "AWSServerMigrationService_V2016_10_24.DeleteAppLaunchConfiguration",
4133        );
4134        let encoded = serde_json::to_string(&input).unwrap();
4135        request.set_payload(Some(encoded));
4136
4137        let response = self
4138            .sign_and_dispatch(request, DeleteAppLaunchConfigurationError::from_response)
4139            .await?;
4140        let mut response = response;
4141        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4142        proto::json::ResponsePayload::new(&response)
4143            .deserialize::<DeleteAppLaunchConfigurationResponse, _>()
4144    }
4145
4146    /// <p>Deletes the replication configuration for the specified application.</p>
4147    async fn delete_app_replication_configuration(
4148        &self,
4149        input: DeleteAppReplicationConfigurationRequest,
4150    ) -> Result<
4151        DeleteAppReplicationConfigurationResponse,
4152        RusotoError<DeleteAppReplicationConfigurationError>,
4153    > {
4154        let mut request = self.new_signed_request("POST", "/");
4155        request.add_header(
4156            "x-amz-target",
4157            "AWSServerMigrationService_V2016_10_24.DeleteAppReplicationConfiguration",
4158        );
4159        let encoded = serde_json::to_string(&input).unwrap();
4160        request.set_payload(Some(encoded));
4161
4162        let response = self
4163            .sign_and_dispatch(
4164                request,
4165                DeleteAppReplicationConfigurationError::from_response,
4166            )
4167            .await?;
4168        let mut response = response;
4169        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4170        proto::json::ResponsePayload::new(&response)
4171            .deserialize::<DeleteAppReplicationConfigurationResponse, _>()
4172    }
4173
4174    /// <p>Deletes the validation configuration for the specified application.</p>
4175    async fn delete_app_validation_configuration(
4176        &self,
4177        input: DeleteAppValidationConfigurationRequest,
4178    ) -> Result<
4179        DeleteAppValidationConfigurationResponse,
4180        RusotoError<DeleteAppValidationConfigurationError>,
4181    > {
4182        let mut request = self.new_signed_request("POST", "/");
4183        request.add_header(
4184            "x-amz-target",
4185            "AWSServerMigrationService_V2016_10_24.DeleteAppValidationConfiguration",
4186        );
4187        let encoded = serde_json::to_string(&input).unwrap();
4188        request.set_payload(Some(encoded));
4189
4190        let response = self
4191            .sign_and_dispatch(
4192                request,
4193                DeleteAppValidationConfigurationError::from_response,
4194            )
4195            .await?;
4196        let mut response = response;
4197        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4198        proto::json::ResponsePayload::new(&response)
4199            .deserialize::<DeleteAppValidationConfigurationResponse, _>()
4200    }
4201
4202    /// <p>Deletes the specified replication job.</p> <p>After you delete a replication job, there are no further replication runs. AWS deletes the contents of the Amazon S3 bucket used to store AWS SMS artifacts. The AMIs created by the replication runs are not deleted.</p>
4203    async fn delete_replication_job(
4204        &self,
4205        input: DeleteReplicationJobRequest,
4206    ) -> Result<DeleteReplicationJobResponse, RusotoError<DeleteReplicationJobError>> {
4207        let mut request = self.new_signed_request("POST", "/");
4208        request.add_header(
4209            "x-amz-target",
4210            "AWSServerMigrationService_V2016_10_24.DeleteReplicationJob",
4211        );
4212        let encoded = serde_json::to_string(&input).unwrap();
4213        request.set_payload(Some(encoded));
4214
4215        let response = self
4216            .sign_and_dispatch(request, DeleteReplicationJobError::from_response)
4217            .await?;
4218        let mut response = response;
4219        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4220        proto::json::ResponsePayload::new(&response)
4221            .deserialize::<DeleteReplicationJobResponse, _>()
4222    }
4223
4224    /// <p>Deletes all servers from your server catalog.</p>
4225    async fn delete_server_catalog(
4226        &self,
4227    ) -> Result<DeleteServerCatalogResponse, RusotoError<DeleteServerCatalogError>> {
4228        let mut request = self.new_signed_request("POST", "/");
4229        request.add_header(
4230            "x-amz-target",
4231            "AWSServerMigrationService_V2016_10_24.DeleteServerCatalog",
4232        );
4233        request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
4234
4235        let response = self
4236            .sign_and_dispatch(request, DeleteServerCatalogError::from_response)
4237            .await?;
4238        let mut response = response;
4239        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4240        proto::json::ResponsePayload::new(&response).deserialize::<DeleteServerCatalogResponse, _>()
4241    }
4242
4243    /// <p>Disassociates the specified connector from AWS SMS.</p> <p>After you disassociate a connector, it is no longer available to support replication jobs.</p>
4244    async fn disassociate_connector(
4245        &self,
4246        input: DisassociateConnectorRequest,
4247    ) -> Result<DisassociateConnectorResponse, RusotoError<DisassociateConnectorError>> {
4248        let mut request = self.new_signed_request("POST", "/");
4249        request.add_header(
4250            "x-amz-target",
4251            "AWSServerMigrationService_V2016_10_24.DisassociateConnector",
4252        );
4253        let encoded = serde_json::to_string(&input).unwrap();
4254        request.set_payload(Some(encoded));
4255
4256        let response = self
4257            .sign_and_dispatch(request, DisassociateConnectorError::from_response)
4258            .await?;
4259        let mut response = response;
4260        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4261        proto::json::ResponsePayload::new(&response)
4262            .deserialize::<DisassociateConnectorResponse, _>()
4263    }
4264
4265    /// <p>Generates a target change set for a currently launched stack and writes it to an Amazon S3 object in the customer’s Amazon S3 bucket.</p>
4266    async fn generate_change_set(
4267        &self,
4268        input: GenerateChangeSetRequest,
4269    ) -> Result<GenerateChangeSetResponse, RusotoError<GenerateChangeSetError>> {
4270        let mut request = self.new_signed_request("POST", "/");
4271        request.add_header(
4272            "x-amz-target",
4273            "AWSServerMigrationService_V2016_10_24.GenerateChangeSet",
4274        );
4275        let encoded = serde_json::to_string(&input).unwrap();
4276        request.set_payload(Some(encoded));
4277
4278        let response = self
4279            .sign_and_dispatch(request, GenerateChangeSetError::from_response)
4280            .await?;
4281        let mut response = response;
4282        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4283        proto::json::ResponsePayload::new(&response).deserialize::<GenerateChangeSetResponse, _>()
4284    }
4285
4286    /// <p>Generates an AWS CloudFormation template based on the current launch configuration and writes it to an Amazon S3 object in the customer’s Amazon S3 bucket.</p>
4287    async fn generate_template(
4288        &self,
4289        input: GenerateTemplateRequest,
4290    ) -> Result<GenerateTemplateResponse, RusotoError<GenerateTemplateError>> {
4291        let mut request = self.new_signed_request("POST", "/");
4292        request.add_header(
4293            "x-amz-target",
4294            "AWSServerMigrationService_V2016_10_24.GenerateTemplate",
4295        );
4296        let encoded = serde_json::to_string(&input).unwrap();
4297        request.set_payload(Some(encoded));
4298
4299        let response = self
4300            .sign_and_dispatch(request, GenerateTemplateError::from_response)
4301            .await?;
4302        let mut response = response;
4303        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4304        proto::json::ResponsePayload::new(&response).deserialize::<GenerateTemplateResponse, _>()
4305    }
4306
4307    /// <p>Retrieve information about the specified application.</p>
4308    async fn get_app(
4309        &self,
4310        input: GetAppRequest,
4311    ) -> Result<GetAppResponse, RusotoError<GetAppError>> {
4312        let mut request = self.new_signed_request("POST", "/");
4313        request.add_header(
4314            "x-amz-target",
4315            "AWSServerMigrationService_V2016_10_24.GetApp",
4316        );
4317        let encoded = serde_json::to_string(&input).unwrap();
4318        request.set_payload(Some(encoded));
4319
4320        let response = self
4321            .sign_and_dispatch(request, GetAppError::from_response)
4322            .await?;
4323        let mut response = response;
4324        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4325        proto::json::ResponsePayload::new(&response).deserialize::<GetAppResponse, _>()
4326    }
4327
4328    /// <p>Retrieves the application launch configuration associated with the specified application.</p>
4329    async fn get_app_launch_configuration(
4330        &self,
4331        input: GetAppLaunchConfigurationRequest,
4332    ) -> Result<GetAppLaunchConfigurationResponse, RusotoError<GetAppLaunchConfigurationError>>
4333    {
4334        let mut request = self.new_signed_request("POST", "/");
4335        request.add_header(
4336            "x-amz-target",
4337            "AWSServerMigrationService_V2016_10_24.GetAppLaunchConfiguration",
4338        );
4339        let encoded = serde_json::to_string(&input).unwrap();
4340        request.set_payload(Some(encoded));
4341
4342        let response = self
4343            .sign_and_dispatch(request, GetAppLaunchConfigurationError::from_response)
4344            .await?;
4345        let mut response = response;
4346        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4347        proto::json::ResponsePayload::new(&response)
4348            .deserialize::<GetAppLaunchConfigurationResponse, _>()
4349    }
4350
4351    /// <p>Retrieves the application replication configuration associated with the specified application.</p>
4352    async fn get_app_replication_configuration(
4353        &self,
4354        input: GetAppReplicationConfigurationRequest,
4355    ) -> Result<
4356        GetAppReplicationConfigurationResponse,
4357        RusotoError<GetAppReplicationConfigurationError>,
4358    > {
4359        let mut request = self.new_signed_request("POST", "/");
4360        request.add_header(
4361            "x-amz-target",
4362            "AWSServerMigrationService_V2016_10_24.GetAppReplicationConfiguration",
4363        );
4364        let encoded = serde_json::to_string(&input).unwrap();
4365        request.set_payload(Some(encoded));
4366
4367        let response = self
4368            .sign_and_dispatch(request, GetAppReplicationConfigurationError::from_response)
4369            .await?;
4370        let mut response = response;
4371        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4372        proto::json::ResponsePayload::new(&response)
4373            .deserialize::<GetAppReplicationConfigurationResponse, _>()
4374    }
4375
4376    /// <p>Retrieves information about a configuration for validating an application.</p>
4377    async fn get_app_validation_configuration(
4378        &self,
4379        input: GetAppValidationConfigurationRequest,
4380    ) -> Result<
4381        GetAppValidationConfigurationResponse,
4382        RusotoError<GetAppValidationConfigurationError>,
4383    > {
4384        let mut request = self.new_signed_request("POST", "/");
4385        request.add_header(
4386            "x-amz-target",
4387            "AWSServerMigrationService_V2016_10_24.GetAppValidationConfiguration",
4388        );
4389        let encoded = serde_json::to_string(&input).unwrap();
4390        request.set_payload(Some(encoded));
4391
4392        let response = self
4393            .sign_and_dispatch(request, GetAppValidationConfigurationError::from_response)
4394            .await?;
4395        let mut response = response;
4396        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4397        proto::json::ResponsePayload::new(&response)
4398            .deserialize::<GetAppValidationConfigurationResponse, _>()
4399    }
4400
4401    /// <p>Retrieves output from validating an application.</p>
4402    async fn get_app_validation_output(
4403        &self,
4404        input: GetAppValidationOutputRequest,
4405    ) -> Result<GetAppValidationOutputResponse, RusotoError<GetAppValidationOutputError>> {
4406        let mut request = self.new_signed_request("POST", "/");
4407        request.add_header(
4408            "x-amz-target",
4409            "AWSServerMigrationService_V2016_10_24.GetAppValidationOutput",
4410        );
4411        let encoded = serde_json::to_string(&input).unwrap();
4412        request.set_payload(Some(encoded));
4413
4414        let response = self
4415            .sign_and_dispatch(request, GetAppValidationOutputError::from_response)
4416            .await?;
4417        let mut response = response;
4418        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4419        proto::json::ResponsePayload::new(&response)
4420            .deserialize::<GetAppValidationOutputResponse, _>()
4421    }
4422
4423    /// <p>Describes the connectors registered with the AWS SMS.</p>
4424    async fn get_connectors(
4425        &self,
4426        input: GetConnectorsRequest,
4427    ) -> Result<GetConnectorsResponse, RusotoError<GetConnectorsError>> {
4428        let mut request = self.new_signed_request("POST", "/");
4429        request.add_header(
4430            "x-amz-target",
4431            "AWSServerMigrationService_V2016_10_24.GetConnectors",
4432        );
4433        let encoded = serde_json::to_string(&input).unwrap();
4434        request.set_payload(Some(encoded));
4435
4436        let response = self
4437            .sign_and_dispatch(request, GetConnectorsError::from_response)
4438            .await?;
4439        let mut response = response;
4440        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4441        proto::json::ResponsePayload::new(&response).deserialize::<GetConnectorsResponse, _>()
4442    }
4443
4444    /// <p>Describes the specified replication job or all of your replication jobs.</p>
4445    async fn get_replication_jobs(
4446        &self,
4447        input: GetReplicationJobsRequest,
4448    ) -> Result<GetReplicationJobsResponse, RusotoError<GetReplicationJobsError>> {
4449        let mut request = self.new_signed_request("POST", "/");
4450        request.add_header(
4451            "x-amz-target",
4452            "AWSServerMigrationService_V2016_10_24.GetReplicationJobs",
4453        );
4454        let encoded = serde_json::to_string(&input).unwrap();
4455        request.set_payload(Some(encoded));
4456
4457        let response = self
4458            .sign_and_dispatch(request, GetReplicationJobsError::from_response)
4459            .await?;
4460        let mut response = response;
4461        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4462        proto::json::ResponsePayload::new(&response).deserialize::<GetReplicationJobsResponse, _>()
4463    }
4464
4465    /// <p>Describes the replication runs for the specified replication job.</p>
4466    async fn get_replication_runs(
4467        &self,
4468        input: GetReplicationRunsRequest,
4469    ) -> Result<GetReplicationRunsResponse, RusotoError<GetReplicationRunsError>> {
4470        let mut request = self.new_signed_request("POST", "/");
4471        request.add_header(
4472            "x-amz-target",
4473            "AWSServerMigrationService_V2016_10_24.GetReplicationRuns",
4474        );
4475        let encoded = serde_json::to_string(&input).unwrap();
4476        request.set_payload(Some(encoded));
4477
4478        let response = self
4479            .sign_and_dispatch(request, GetReplicationRunsError::from_response)
4480            .await?;
4481        let mut response = response;
4482        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4483        proto::json::ResponsePayload::new(&response).deserialize::<GetReplicationRunsResponse, _>()
4484    }
4485
4486    /// <p>Describes the servers in your server catalog.</p> <p>Before you can describe your servers, you must import them using <a>ImportServerCatalog</a>.</p>
4487    async fn get_servers(
4488        &self,
4489        input: GetServersRequest,
4490    ) -> Result<GetServersResponse, RusotoError<GetServersError>> {
4491        let mut request = self.new_signed_request("POST", "/");
4492        request.add_header(
4493            "x-amz-target",
4494            "AWSServerMigrationService_V2016_10_24.GetServers",
4495        );
4496        let encoded = serde_json::to_string(&input).unwrap();
4497        request.set_payload(Some(encoded));
4498
4499        let response = self
4500            .sign_and_dispatch(request, GetServersError::from_response)
4501            .await?;
4502        let mut response = response;
4503        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4504        proto::json::ResponsePayload::new(&response).deserialize::<GetServersResponse, _>()
4505    }
4506
4507    /// <p>Allows application import from AWS Migration Hub.</p>
4508    async fn import_app_catalog(
4509        &self,
4510        input: ImportAppCatalogRequest,
4511    ) -> Result<ImportAppCatalogResponse, RusotoError<ImportAppCatalogError>> {
4512        let mut request = self.new_signed_request("POST", "/");
4513        request.add_header(
4514            "x-amz-target",
4515            "AWSServerMigrationService_V2016_10_24.ImportAppCatalog",
4516        );
4517        let encoded = serde_json::to_string(&input).unwrap();
4518        request.set_payload(Some(encoded));
4519
4520        let response = self
4521            .sign_and_dispatch(request, ImportAppCatalogError::from_response)
4522            .await?;
4523        let mut response = response;
4524        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4525        proto::json::ResponsePayload::new(&response).deserialize::<ImportAppCatalogResponse, _>()
4526    }
4527
4528    /// <p>Gathers a complete list of on-premises servers. Connectors must be installed and monitoring all servers to import.</p> <p>This call returns immediately, but might take additional time to retrieve all the servers.</p>
4529    async fn import_server_catalog(
4530        &self,
4531    ) -> Result<ImportServerCatalogResponse, RusotoError<ImportServerCatalogError>> {
4532        let mut request = self.new_signed_request("POST", "/");
4533        request.add_header(
4534            "x-amz-target",
4535            "AWSServerMigrationService_V2016_10_24.ImportServerCatalog",
4536        );
4537        request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
4538
4539        let response = self
4540            .sign_and_dispatch(request, ImportServerCatalogError::from_response)
4541            .await?;
4542        let mut response = response;
4543        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4544        proto::json::ResponsePayload::new(&response).deserialize::<ImportServerCatalogResponse, _>()
4545    }
4546
4547    /// <p>Launches the specified application as a stack in AWS CloudFormation.</p>
4548    async fn launch_app(
4549        &self,
4550        input: LaunchAppRequest,
4551    ) -> Result<LaunchAppResponse, RusotoError<LaunchAppError>> {
4552        let mut request = self.new_signed_request("POST", "/");
4553        request.add_header(
4554            "x-amz-target",
4555            "AWSServerMigrationService_V2016_10_24.LaunchApp",
4556        );
4557        let encoded = serde_json::to_string(&input).unwrap();
4558        request.set_payload(Some(encoded));
4559
4560        let response = self
4561            .sign_and_dispatch(request, LaunchAppError::from_response)
4562            .await?;
4563        let mut response = response;
4564        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4565        proto::json::ResponsePayload::new(&response).deserialize::<LaunchAppResponse, _>()
4566    }
4567
4568    /// <p>Retrieves summaries for all applications.</p>
4569    async fn list_apps(
4570        &self,
4571        input: ListAppsRequest,
4572    ) -> Result<ListAppsResponse, RusotoError<ListAppsError>> {
4573        let mut request = self.new_signed_request("POST", "/");
4574        request.add_header(
4575            "x-amz-target",
4576            "AWSServerMigrationService_V2016_10_24.ListApps",
4577        );
4578        let encoded = serde_json::to_string(&input).unwrap();
4579        request.set_payload(Some(encoded));
4580
4581        let response = self
4582            .sign_and_dispatch(request, ListAppsError::from_response)
4583            .await?;
4584        let mut response = response;
4585        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4586        proto::json::ResponsePayload::new(&response).deserialize::<ListAppsResponse, _>()
4587    }
4588
4589    /// <p>Provides information to AWS SMS about whether application validation is successful.</p>
4590    async fn notify_app_validation_output(
4591        &self,
4592        input: NotifyAppValidationOutputRequest,
4593    ) -> Result<NotifyAppValidationOutputResponse, RusotoError<NotifyAppValidationOutputError>>
4594    {
4595        let mut request = self.new_signed_request("POST", "/");
4596        request.add_header(
4597            "x-amz-target",
4598            "AWSServerMigrationService_V2016_10_24.NotifyAppValidationOutput",
4599        );
4600        let encoded = serde_json::to_string(&input).unwrap();
4601        request.set_payload(Some(encoded));
4602
4603        let response = self
4604            .sign_and_dispatch(request, NotifyAppValidationOutputError::from_response)
4605            .await?;
4606        let mut response = response;
4607        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4608        proto::json::ResponsePayload::new(&response)
4609            .deserialize::<NotifyAppValidationOutputResponse, _>()
4610    }
4611
4612    /// <p>Creates or updates the launch configuration for the specified application.</p>
4613    async fn put_app_launch_configuration(
4614        &self,
4615        input: PutAppLaunchConfigurationRequest,
4616    ) -> Result<PutAppLaunchConfigurationResponse, RusotoError<PutAppLaunchConfigurationError>>
4617    {
4618        let mut request = self.new_signed_request("POST", "/");
4619        request.add_header(
4620            "x-amz-target",
4621            "AWSServerMigrationService_V2016_10_24.PutAppLaunchConfiguration",
4622        );
4623        let encoded = serde_json::to_string(&input).unwrap();
4624        request.set_payload(Some(encoded));
4625
4626        let response = self
4627            .sign_and_dispatch(request, PutAppLaunchConfigurationError::from_response)
4628            .await?;
4629        let mut response = response;
4630        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4631        proto::json::ResponsePayload::new(&response)
4632            .deserialize::<PutAppLaunchConfigurationResponse, _>()
4633    }
4634
4635    /// <p>Creates or updates the replication configuration for the specified application.</p>
4636    async fn put_app_replication_configuration(
4637        &self,
4638        input: PutAppReplicationConfigurationRequest,
4639    ) -> Result<
4640        PutAppReplicationConfigurationResponse,
4641        RusotoError<PutAppReplicationConfigurationError>,
4642    > {
4643        let mut request = self.new_signed_request("POST", "/");
4644        request.add_header(
4645            "x-amz-target",
4646            "AWSServerMigrationService_V2016_10_24.PutAppReplicationConfiguration",
4647        );
4648        let encoded = serde_json::to_string(&input).unwrap();
4649        request.set_payload(Some(encoded));
4650
4651        let response = self
4652            .sign_and_dispatch(request, PutAppReplicationConfigurationError::from_response)
4653            .await?;
4654        let mut response = response;
4655        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4656        proto::json::ResponsePayload::new(&response)
4657            .deserialize::<PutAppReplicationConfigurationResponse, _>()
4658    }
4659
4660    /// <p>Creates or updates a validation configuration for the specified application.</p>
4661    async fn put_app_validation_configuration(
4662        &self,
4663        input: PutAppValidationConfigurationRequest,
4664    ) -> Result<
4665        PutAppValidationConfigurationResponse,
4666        RusotoError<PutAppValidationConfigurationError>,
4667    > {
4668        let mut request = self.new_signed_request("POST", "/");
4669        request.add_header(
4670            "x-amz-target",
4671            "AWSServerMigrationService_V2016_10_24.PutAppValidationConfiguration",
4672        );
4673        let encoded = serde_json::to_string(&input).unwrap();
4674        request.set_payload(Some(encoded));
4675
4676        let response = self
4677            .sign_and_dispatch(request, PutAppValidationConfigurationError::from_response)
4678            .await?;
4679        let mut response = response;
4680        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4681        proto::json::ResponsePayload::new(&response)
4682            .deserialize::<PutAppValidationConfigurationResponse, _>()
4683    }
4684
4685    /// <p>Starts replicating the specified application by creating replication jobs for each server in the application.</p>
4686    async fn start_app_replication(
4687        &self,
4688        input: StartAppReplicationRequest,
4689    ) -> Result<StartAppReplicationResponse, RusotoError<StartAppReplicationError>> {
4690        let mut request = self.new_signed_request("POST", "/");
4691        request.add_header(
4692            "x-amz-target",
4693            "AWSServerMigrationService_V2016_10_24.StartAppReplication",
4694        );
4695        let encoded = serde_json::to_string(&input).unwrap();
4696        request.set_payload(Some(encoded));
4697
4698        let response = self
4699            .sign_and_dispatch(request, StartAppReplicationError::from_response)
4700            .await?;
4701        let mut response = response;
4702        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4703        proto::json::ResponsePayload::new(&response).deserialize::<StartAppReplicationResponse, _>()
4704    }
4705
4706    /// <p>Starts an on-demand replication run for the specified application.</p>
4707    async fn start_on_demand_app_replication(
4708        &self,
4709        input: StartOnDemandAppReplicationRequest,
4710    ) -> Result<StartOnDemandAppReplicationResponse, RusotoError<StartOnDemandAppReplicationError>>
4711    {
4712        let mut request = self.new_signed_request("POST", "/");
4713        request.add_header(
4714            "x-amz-target",
4715            "AWSServerMigrationService_V2016_10_24.StartOnDemandAppReplication",
4716        );
4717        let encoded = serde_json::to_string(&input).unwrap();
4718        request.set_payload(Some(encoded));
4719
4720        let response = self
4721            .sign_and_dispatch(request, StartOnDemandAppReplicationError::from_response)
4722            .await?;
4723        let mut response = response;
4724        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4725        proto::json::ResponsePayload::new(&response)
4726            .deserialize::<StartOnDemandAppReplicationResponse, _>()
4727    }
4728
4729    /// <p>Starts an on-demand replication run for the specified replication job. This replication run starts immediately. This replication run is in addition to the ones already scheduled.</p> <p>There is a limit on the number of on-demand replications runs that you can request in a 24-hour period.</p>
4730    async fn start_on_demand_replication_run(
4731        &self,
4732        input: StartOnDemandReplicationRunRequest,
4733    ) -> Result<StartOnDemandReplicationRunResponse, RusotoError<StartOnDemandReplicationRunError>>
4734    {
4735        let mut request = self.new_signed_request("POST", "/");
4736        request.add_header(
4737            "x-amz-target",
4738            "AWSServerMigrationService_V2016_10_24.StartOnDemandReplicationRun",
4739        );
4740        let encoded = serde_json::to_string(&input).unwrap();
4741        request.set_payload(Some(encoded));
4742
4743        let response = self
4744            .sign_and_dispatch(request, StartOnDemandReplicationRunError::from_response)
4745            .await?;
4746        let mut response = response;
4747        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4748        proto::json::ResponsePayload::new(&response)
4749            .deserialize::<StartOnDemandReplicationRunResponse, _>()
4750    }
4751
4752    /// <p>Stops replicating the specified application by deleting the replication job for each server in the application.</p>
4753    async fn stop_app_replication(
4754        &self,
4755        input: StopAppReplicationRequest,
4756    ) -> Result<StopAppReplicationResponse, RusotoError<StopAppReplicationError>> {
4757        let mut request = self.new_signed_request("POST", "/");
4758        request.add_header(
4759            "x-amz-target",
4760            "AWSServerMigrationService_V2016_10_24.StopAppReplication",
4761        );
4762        let encoded = serde_json::to_string(&input).unwrap();
4763        request.set_payload(Some(encoded));
4764
4765        let response = self
4766            .sign_and_dispatch(request, StopAppReplicationError::from_response)
4767            .await?;
4768        let mut response = response;
4769        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4770        proto::json::ResponsePayload::new(&response).deserialize::<StopAppReplicationResponse, _>()
4771    }
4772
4773    /// <p>Terminates the stack for the specified application.</p>
4774    async fn terminate_app(
4775        &self,
4776        input: TerminateAppRequest,
4777    ) -> Result<TerminateAppResponse, RusotoError<TerminateAppError>> {
4778        let mut request = self.new_signed_request("POST", "/");
4779        request.add_header(
4780            "x-amz-target",
4781            "AWSServerMigrationService_V2016_10_24.TerminateApp",
4782        );
4783        let encoded = serde_json::to_string(&input).unwrap();
4784        request.set_payload(Some(encoded));
4785
4786        let response = self
4787            .sign_and_dispatch(request, TerminateAppError::from_response)
4788            .await?;
4789        let mut response = response;
4790        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4791        proto::json::ResponsePayload::new(&response).deserialize::<TerminateAppResponse, _>()
4792    }
4793
4794    /// <p>Updates the specified application.</p>
4795    async fn update_app(
4796        &self,
4797        input: UpdateAppRequest,
4798    ) -> Result<UpdateAppResponse, RusotoError<UpdateAppError>> {
4799        let mut request = self.new_signed_request("POST", "/");
4800        request.add_header(
4801            "x-amz-target",
4802            "AWSServerMigrationService_V2016_10_24.UpdateApp",
4803        );
4804        let encoded = serde_json::to_string(&input).unwrap();
4805        request.set_payload(Some(encoded));
4806
4807        let response = self
4808            .sign_and_dispatch(request, UpdateAppError::from_response)
4809            .await?;
4810        let mut response = response;
4811        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4812        proto::json::ResponsePayload::new(&response).deserialize::<UpdateAppResponse, _>()
4813    }
4814
4815    /// <p>Updates the specified settings for the specified replication job.</p>
4816    async fn update_replication_job(
4817        &self,
4818        input: UpdateReplicationJobRequest,
4819    ) -> Result<UpdateReplicationJobResponse, RusotoError<UpdateReplicationJobError>> {
4820        let mut request = self.new_signed_request("POST", "/");
4821        request.add_header(
4822            "x-amz-target",
4823            "AWSServerMigrationService_V2016_10_24.UpdateReplicationJob",
4824        );
4825        let encoded = serde_json::to_string(&input).unwrap();
4826        request.set_payload(Some(encoded));
4827
4828        let response = self
4829            .sign_and_dispatch(request, UpdateReplicationJobError::from_response)
4830            .await?;
4831        let mut response = response;
4832        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4833        proto::json::ResponsePayload::new(&response)
4834            .deserialize::<UpdateReplicationJobResponse, _>()
4835    }
4836}
rusoto_sms/generated.rs

rusoto_sms/
generated.rs
