use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl DeviceFarmClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "devicefarm", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AccountSettings {
#[serde(rename = "awsAccountNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_account_number: Option<String>,
#[serde(rename = "defaultJobTimeoutMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_job_timeout_minutes: Option<i64>,
#[serde(rename = "maxJobTimeoutMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_job_timeout_minutes: Option<i64>,
#[serde(rename = "maxSlots")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_slots: Option<::std::collections::HashMap<String, i64>>,
#[serde(rename = "skipAppResign")]
#[serde(skip_serializing_if = "Option::is_none")]
pub skip_app_resign: Option<bool>,
#[serde(rename = "trialMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trial_minutes: Option<TrialMinutes>,
#[serde(rename = "unmeteredDevices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unmetered_devices: Option<::std::collections::HashMap<String, i64>>,
#[serde(rename = "unmeteredRemoteAccessDevices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unmetered_remote_access_devices: Option<::std::collections::HashMap<String, i64>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Artifact {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "extension")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extension: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "url")]
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CPU {
#[serde(rename = "architecture")]
#[serde(skip_serializing_if = "Option::is_none")]
pub architecture: Option<String>,
#[serde(rename = "clock")]
#[serde(skip_serializing_if = "Option::is_none")]
pub clock: Option<f64>,
#[serde(rename = "frequency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub frequency: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Counters {
#[serde(rename = "errored")]
#[serde(skip_serializing_if = "Option::is_none")]
pub errored: Option<i64>,
#[serde(rename = "failed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed: Option<i64>,
#[serde(rename = "passed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub passed: Option<i64>,
#[serde(rename = "skipped")]
#[serde(skip_serializing_if = "Option::is_none")]
pub skipped: Option<i64>,
#[serde(rename = "stopped")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stopped: Option<i64>,
#[serde(rename = "total")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total: Option<i64>,
#[serde(rename = "warned")]
#[serde(skip_serializing_if = "Option::is_none")]
pub warned: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDevicePoolRequest {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "maxDevices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_devices: Option<i64>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "projectArn")]
pub project_arn: String,
#[serde(rename = "rules")]
pub rules: Vec<Rule>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDevicePoolResult {
#[serde(rename = "devicePool")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_pool: Option<DevicePool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateInstanceProfileRequest {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "excludeAppPackagesFromCleanup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclude_app_packages_from_cleanup: Option<Vec<String>>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "packageCleanup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_cleanup: Option<bool>,
#[serde(rename = "rebootAfterUse")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reboot_after_use: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateInstanceProfileResult {
#[serde(rename = "instanceProfile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_profile: Option<InstanceProfile>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateNetworkProfileRequest {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "downlinkBandwidthBits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub downlink_bandwidth_bits: Option<i64>,
#[serde(rename = "downlinkDelayMs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub downlink_delay_ms: Option<i64>,
#[serde(rename = "downlinkJitterMs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub downlink_jitter_ms: Option<i64>,
#[serde(rename = "downlinkLossPercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub downlink_loss_percent: Option<i64>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "projectArn")]
pub project_arn: String,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "uplinkBandwidthBits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uplink_bandwidth_bits: Option<i64>,
#[serde(rename = "uplinkDelayMs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uplink_delay_ms: Option<i64>,
#[serde(rename = "uplinkJitterMs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uplink_jitter_ms: Option<i64>,
#[serde(rename = "uplinkLossPercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uplink_loss_percent: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateNetworkProfileResult {
#[serde(rename = "networkProfile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_profile: Option<NetworkProfile>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateProjectRequest {
#[serde(rename = "defaultJobTimeoutMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_job_timeout_minutes: Option<i64>,
#[serde(rename = "name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateProjectResult {
#[serde(rename = "project")]
#[serde(skip_serializing_if = "Option::is_none")]
pub project: Option<Project>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateRemoteAccessSessionConfiguration {
#[serde(rename = "billingMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub billing_method: Option<String>,
#[serde(rename = "vpceConfigurationArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpce_configuration_arns: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateRemoteAccessSessionRequest {
#[serde(rename = "clientId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
#[serde(rename = "configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<CreateRemoteAccessSessionConfiguration>,
#[serde(rename = "deviceArn")]
pub device_arn: String,
#[serde(rename = "instanceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_arn: Option<String>,
#[serde(rename = "interactionMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub interaction_mode: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "projectArn")]
pub project_arn: String,
#[serde(rename = "remoteDebugEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_debug_enabled: Option<bool>,
#[serde(rename = "remoteRecordAppArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_record_app_arn: Option<String>,
#[serde(rename = "remoteRecordEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_record_enabled: Option<bool>,
#[serde(rename = "skipAppResign")]
#[serde(skip_serializing_if = "Option::is_none")]
pub skip_app_resign: Option<bool>,
#[serde(rename = "sshPublicKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_public_key: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateRemoteAccessSessionResult {
#[serde(rename = "remoteAccessSession")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_access_session: Option<RemoteAccessSession>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTestGridProjectRequest {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTestGridProjectResult {
#[serde(rename = "testGridProject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_grid_project: Option<TestGridProject>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTestGridUrlRequest {
#[serde(rename = "expiresInSeconds")]
pub expires_in_seconds: i64,
#[serde(rename = "projectArn")]
pub project_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTestGridUrlResult {
#[serde(rename = "expires")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expires: Option<f64>,
#[serde(rename = "url")]
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateUploadRequest {
#[serde(rename = "contentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_type: Option<String>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "projectArn")]
pub project_arn: String,
#[serde(rename = "type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateUploadResult {
#[serde(rename = "upload")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upload: Option<Upload>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateVPCEConfigurationRequest {
#[serde(rename = "serviceDnsName")]
pub service_dns_name: String,
#[serde(rename = "vpceConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpce_configuration_description: Option<String>,
#[serde(rename = "vpceConfigurationName")]
pub vpce_configuration_name: String,
#[serde(rename = "vpceServiceName")]
pub vpce_service_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateVPCEConfigurationResult {
#[serde(rename = "vpceConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpce_configuration: Option<VPCEConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CustomerArtifactPaths {
#[serde(rename = "androidPaths")]
#[serde(skip_serializing_if = "Option::is_none")]
pub android_paths: Option<Vec<String>>,
#[serde(rename = "deviceHostPaths")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_host_paths: Option<Vec<String>>,
#[serde(rename = "iosPaths")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ios_paths: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDevicePoolRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDevicePoolResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteInstanceProfileRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteInstanceProfileResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteNetworkProfileRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteNetworkProfileResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteProjectRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteProjectResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteRemoteAccessSessionRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteRemoteAccessSessionResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteRunRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteRunResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTestGridProjectRequest {
#[serde(rename = "projectArn")]
pub project_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteTestGridProjectResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteUploadRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteUploadResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteVPCEConfigurationRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteVPCEConfigurationResult {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Device {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "availability")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability: Option<String>,
#[serde(rename = "carrier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub carrier: Option<String>,
#[serde(rename = "cpu")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cpu: Option<CPU>,
#[serde(rename = "fleetName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet_name: Option<String>,
#[serde(rename = "fleetType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet_type: Option<String>,
#[serde(rename = "formFactor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub form_factor: Option<String>,
#[serde(rename = "heapSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub heap_size: Option<i64>,
#[serde(rename = "image")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image: Option<String>,
#[serde(rename = "instances")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instances: Option<Vec<DeviceInstance>>,
#[serde(rename = "manufacturer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manufacturer: Option<String>,
#[serde(rename = "memory")]
#[serde(skip_serializing_if = "Option::is_none")]
pub memory: Option<i64>,
#[serde(rename = "model")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model: Option<String>,
#[serde(rename = "modelId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_id: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "os")]
#[serde(skip_serializing_if = "Option::is_none")]
pub os: Option<String>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "radio")]
#[serde(skip_serializing_if = "Option::is_none")]
pub radio: Option<String>,
#[serde(rename = "remoteAccessEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_access_enabled: Option<bool>,
#[serde(rename = "remoteDebugEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_debug_enabled: Option<bool>,
#[serde(rename = "resolution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolution: Option<Resolution>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeviceFilter {
#[serde(rename = "attribute")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute: Option<String>,
#[serde(rename = "operator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operator: Option<String>,
#[serde(rename = "values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeviceInstance {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "deviceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_arn: Option<String>,
#[serde(rename = "instanceProfile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_profile: Option<InstanceProfile>,
#[serde(rename = "labels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub labels: Option<Vec<String>>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "udid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub udid: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeviceMinutes {
#[serde(rename = "metered")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metered: Option<f64>,
#[serde(rename = "total")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total: Option<f64>,
#[serde(rename = "unmetered")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unmetered: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DevicePool {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "maxDevices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_devices: Option<i64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "rules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rules: Option<Vec<Rule>>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DevicePoolCompatibilityResult {
#[serde(rename = "compatible")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compatible: Option<bool>,
#[serde(rename = "device")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device: Option<Device>,
#[serde(rename = "incompatibilityMessages")]
#[serde(skip_serializing_if = "Option::is_none")]
pub incompatibility_messages: Option<Vec<IncompatibilityMessage>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeviceSelectionConfiguration {
#[serde(rename = "filters")]
pub filters: Vec<DeviceFilter>,
#[serde(rename = "maxDevices")]
pub max_devices: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeviceSelectionResult {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<DeviceFilter>>,
#[serde(rename = "matchedDevicesCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub matched_devices_count: Option<i64>,
#[serde(rename = "maxDevices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_devices: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ExecutionConfiguration {
#[serde(rename = "accountsCleanup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accounts_cleanup: Option<bool>,
#[serde(rename = "appPackagesCleanup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_packages_cleanup: Option<bool>,
#[serde(rename = "jobTimeoutMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_timeout_minutes: Option<i64>,
#[serde(rename = "skipAppResign")]
#[serde(skip_serializing_if = "Option::is_none")]
pub skip_app_resign: Option<bool>,
#[serde(rename = "videoCapture")]
#[serde(skip_serializing_if = "Option::is_none")]
pub video_capture: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAccountSettingsRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAccountSettingsResult {
#[serde(rename = "accountSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_settings: Option<AccountSettings>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeviceInstanceRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDeviceInstanceResult {
#[serde(rename = "deviceInstance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_instance: Option<DeviceInstance>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDevicePoolCompatibilityRequest {
#[serde(rename = "appArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_arn: Option<String>,
#[serde(rename = "configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<ScheduleRunConfiguration>,
#[serde(rename = "devicePoolArn")]
pub device_pool_arn: String,
#[serde(rename = "test")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test: Option<ScheduleRunTest>,
#[serde(rename = "testType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDevicePoolCompatibilityResult {
#[serde(rename = "compatibleDevices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compatible_devices: Option<Vec<DevicePoolCompatibilityResult>>,
#[serde(rename = "incompatibleDevices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub incompatible_devices: Option<Vec<DevicePoolCompatibilityResult>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDevicePoolRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDevicePoolResult {
#[serde(rename = "devicePool")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_pool: Option<DevicePool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeviceRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDeviceResult {
#[serde(rename = "device")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device: Option<Device>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetInstanceProfileRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetInstanceProfileResult {
#[serde(rename = "instanceProfile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_profile: Option<InstanceProfile>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetJobRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetJobResult {
#[serde(rename = "job")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job: Option<Job>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetNetworkProfileRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetNetworkProfileResult {
#[serde(rename = "networkProfile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_profile: Option<NetworkProfile>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetOfferingStatusRequest {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetOfferingStatusResult {
#[serde(rename = "current")]
#[serde(skip_serializing_if = "Option::is_none")]
pub current: Option<::std::collections::HashMap<String, OfferingStatus>>,
#[serde(rename = "nextPeriod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_period: Option<::std::collections::HashMap<String, OfferingStatus>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetProjectRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetProjectResult {
#[serde(rename = "project")]
#[serde(skip_serializing_if = "Option::is_none")]
pub project: Option<Project>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRemoteAccessSessionRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRemoteAccessSessionResult {
#[serde(rename = "remoteAccessSession")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_access_session: Option<RemoteAccessSession>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRunRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRunResult {
#[serde(rename = "run")]
#[serde(skip_serializing_if = "Option::is_none")]
pub run: Option<Run>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSuiteRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSuiteResult {
#[serde(rename = "suite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub suite: Option<Suite>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetTestGridProjectRequest {
#[serde(rename = "projectArn")]
pub project_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetTestGridProjectResult {
#[serde(rename = "testGridProject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_grid_project: Option<TestGridProject>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetTestGridSessionRequest {
#[serde(rename = "projectArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub project_arn: Option<String>,
#[serde(rename = "sessionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub session_arn: Option<String>,
#[serde(rename = "sessionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub session_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetTestGridSessionResult {
#[serde(rename = "testGridSession")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_grid_session: Option<TestGridSession>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetTestRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetTestResult {
#[serde(rename = "test")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test: Option<Test>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetUploadRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetUploadResult {
#[serde(rename = "upload")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upload: Option<Upload>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetVPCEConfigurationRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetVPCEConfigurationResult {
#[serde(rename = "vpceConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpce_configuration: Option<VPCEConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IncompatibilityMessage {
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InstallToRemoteAccessSessionRequest {
#[serde(rename = "appArn")]
pub app_arn: String,
#[serde(rename = "remoteAccessSessionArn")]
pub remote_access_session_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstallToRemoteAccessSessionResult {
#[serde(rename = "appUpload")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_upload: Option<Upload>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstanceProfile {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "excludeAppPackagesFromCleanup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclude_app_packages_from_cleanup: Option<Vec<String>>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "packageCleanup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_cleanup: Option<bool>,
#[serde(rename = "rebootAfterUse")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reboot_after_use: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Job {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "counters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub counters: Option<Counters>,
#[serde(rename = "created")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created: Option<f64>,
#[serde(rename = "device")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device: Option<Device>,
#[serde(rename = "deviceMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_minutes: Option<DeviceMinutes>,
#[serde(rename = "instanceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_arn: Option<String>,
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "result")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result: Option<String>,
#[serde(rename = "started")]
#[serde(skip_serializing_if = "Option::is_none")]
pub started: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "stopped")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stopped: Option<f64>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "videoCapture")]
#[serde(skip_serializing_if = "Option::is_none")]
pub video_capture: Option<bool>,
#[serde(rename = "videoEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub video_endpoint: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListArtifactsRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListArtifactsResult {
#[serde(rename = "artifacts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub artifacts: Option<Vec<Artifact>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDeviceInstancesRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDeviceInstancesResult {
#[serde(rename = "deviceInstances")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_instances: Option<Vec<DeviceInstance>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDevicePoolsRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDevicePoolsResult {
#[serde(rename = "devicePools")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_pools: Option<Vec<DevicePool>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDevicesRequest {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<DeviceFilter>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDevicesResult {
#[serde(rename = "devices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub devices: Option<Vec<Device>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListInstanceProfilesRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListInstanceProfilesResult {
#[serde(rename = "instanceProfiles")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_profiles: Option<Vec<InstanceProfile>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListJobsRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListJobsResult {
#[serde(rename = "jobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jobs: Option<Vec<Job>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListNetworkProfilesRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListNetworkProfilesResult {
#[serde(rename = "networkProfiles")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_profiles: Option<Vec<NetworkProfile>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListOfferingPromotionsRequest {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListOfferingPromotionsResult {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "offeringPromotions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub offering_promotions: Option<Vec<OfferingPromotion>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListOfferingTransactionsRequest {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListOfferingTransactionsResult {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "offeringTransactions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub offering_transactions: Option<Vec<OfferingTransaction>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListOfferingsRequest {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListOfferingsResult {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "offerings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub offerings: Option<Vec<Offering>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListProjectsRequest {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListProjectsResult {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "projects")]
#[serde(skip_serializing_if = "Option::is_none")]
pub projects: Option<Vec<Project>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRemoteAccessSessionsRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListRemoteAccessSessionsResult {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "remoteAccessSessions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_access_sessions: Option<Vec<RemoteAccessSession>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRunsRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListRunsResult {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "runs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub runs: Option<Vec<Run>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListSamplesRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListSamplesResult {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "samples")]
#[serde(skip_serializing_if = "Option::is_none")]
pub samples: Option<Vec<Sample>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListSuitesRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListSuitesResult {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "suites")]
#[serde(skip_serializing_if = "Option::is_none")]
pub suites: Option<Vec<Suite>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTestGridProjectsRequest {
#[serde(rename = "maxResult")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_result: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTestGridProjectsResult {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "testGridProjects")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_grid_projects: Option<Vec<TestGridProject>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTestGridSessionActionsRequest {
#[serde(rename = "maxResult")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_result: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "sessionArn")]
pub session_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTestGridSessionActionsResult {
#[serde(rename = "actions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub actions: Option<Vec<TestGridSessionAction>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTestGridSessionArtifactsRequest {
#[serde(rename = "maxResult")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_result: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "sessionArn")]
pub session_arn: String,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTestGridSessionArtifactsResult {
#[serde(rename = "artifacts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub artifacts: Option<Vec<TestGridSessionArtifact>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTestGridSessionsRequest {
#[serde(rename = "creationTimeAfter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time_after: Option<f64>,
#[serde(rename = "creationTimeBefore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time_before: Option<f64>,
#[serde(rename = "endTimeAfter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time_after: Option<f64>,
#[serde(rename = "endTimeBefore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time_before: Option<f64>,
#[serde(rename = "maxResult")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_result: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "projectArn")]
pub project_arn: String,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTestGridSessionsResult {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "testGridSessions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_grid_sessions: Option<Vec<TestGridSession>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTestsRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTestsResult {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "tests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tests: Option<Vec<Test>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListUniqueProblemsRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListUniqueProblemsResult {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "uniqueProblems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unique_problems: Option<::std::collections::HashMap<String, Vec<UniqueProblem>>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListUploadsRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListUploadsResult {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "uploads")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uploads: Option<Vec<Upload>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListVPCEConfigurationsRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListVPCEConfigurationsResult {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "vpceConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpce_configurations: Option<Vec<VPCEConfiguration>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Location {
#[serde(rename = "latitude")]
pub latitude: f64,
#[serde(rename = "longitude")]
pub longitude: f64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MonetaryAmount {
#[serde(rename = "amount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amount: Option<f64>,
#[serde(rename = "currencyCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub currency_code: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NetworkProfile {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "downlinkBandwidthBits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub downlink_bandwidth_bits: Option<i64>,
#[serde(rename = "downlinkDelayMs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub downlink_delay_ms: Option<i64>,
#[serde(rename = "downlinkJitterMs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub downlink_jitter_ms: Option<i64>,
#[serde(rename = "downlinkLossPercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub downlink_loss_percent: Option<i64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "uplinkBandwidthBits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uplink_bandwidth_bits: Option<i64>,
#[serde(rename = "uplinkDelayMs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uplink_delay_ms: Option<i64>,
#[serde(rename = "uplinkJitterMs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uplink_jitter_ms: Option<i64>,
#[serde(rename = "uplinkLossPercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uplink_loss_percent: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Offering {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "recurringCharges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recurring_charges: Option<Vec<RecurringCharge>>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OfferingPromotion {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OfferingStatus {
#[serde(rename = "effectiveOn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub effective_on: Option<f64>,
#[serde(rename = "offering")]
#[serde(skip_serializing_if = "Option::is_none")]
pub offering: Option<Offering>,
#[serde(rename = "quantity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quantity: Option<i64>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OfferingTransaction {
#[serde(rename = "cost")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cost: Option<MonetaryAmount>,
#[serde(rename = "createdOn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_on: Option<f64>,
#[serde(rename = "offeringPromotionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub offering_promotion_id: Option<String>,
#[serde(rename = "offeringStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub offering_status: Option<OfferingStatus>,
#[serde(rename = "transactionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transaction_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Problem {
#[serde(rename = "device")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device: Option<Device>,
#[serde(rename = "job")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job: Option<ProblemDetail>,
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "result")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result: Option<String>,
#[serde(rename = "run")]
#[serde(skip_serializing_if = "Option::is_none")]
pub run: Option<ProblemDetail>,
#[serde(rename = "suite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub suite: Option<ProblemDetail>,
#[serde(rename = "test")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test: Option<ProblemDetail>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProblemDetail {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Project {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "created")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created: Option<f64>,
#[serde(rename = "defaultJobTimeoutMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_job_timeout_minutes: Option<i64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PurchaseOfferingRequest {
#[serde(rename = "offeringId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub offering_id: Option<String>,
#[serde(rename = "offeringPromotionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub offering_promotion_id: Option<String>,
#[serde(rename = "quantity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quantity: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PurchaseOfferingResult {
#[serde(rename = "offeringTransaction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub offering_transaction: Option<OfferingTransaction>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Radios {
#[serde(rename = "bluetooth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bluetooth: Option<bool>,
#[serde(rename = "gps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gps: Option<bool>,
#[serde(rename = "nfc")]
#[serde(skip_serializing_if = "Option::is_none")]
pub nfc: Option<bool>,
#[serde(rename = "wifi")]
#[serde(skip_serializing_if = "Option::is_none")]
pub wifi: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecurringCharge {
#[serde(rename = "cost")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cost: Option<MonetaryAmount>,
#[serde(rename = "frequency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub frequency: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RemoteAccessSession {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "billingMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub billing_method: Option<String>,
#[serde(rename = "clientId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
#[serde(rename = "created")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created: Option<f64>,
#[serde(rename = "device")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device: Option<Device>,
#[serde(rename = "deviceMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_minutes: Option<DeviceMinutes>,
#[serde(rename = "deviceUdid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_udid: Option<String>,
#[serde(rename = "endpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint: Option<String>,
#[serde(rename = "hostAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub host_address: Option<String>,
#[serde(rename = "instanceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_arn: Option<String>,
#[serde(rename = "interactionMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub interaction_mode: Option<String>,
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "remoteDebugEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_debug_enabled: Option<bool>,
#[serde(rename = "remoteRecordAppArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_record_app_arn: Option<String>,
#[serde(rename = "remoteRecordEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_record_enabled: Option<bool>,
#[serde(rename = "result")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result: Option<String>,
#[serde(rename = "skipAppResign")]
#[serde(skip_serializing_if = "Option::is_none")]
pub skip_app_resign: Option<bool>,
#[serde(rename = "started")]
#[serde(skip_serializing_if = "Option::is_none")]
pub started: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "stopped")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stopped: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RenewOfferingRequest {
#[serde(rename = "offeringId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub offering_id: Option<String>,
#[serde(rename = "quantity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quantity: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RenewOfferingResult {
#[serde(rename = "offeringTransaction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub offering_transaction: Option<OfferingTransaction>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Resolution {
#[serde(rename = "height")]
#[serde(skip_serializing_if = "Option::is_none")]
pub height: Option<i64>,
#[serde(rename = "width")]
#[serde(skip_serializing_if = "Option::is_none")]
pub width: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Rule {
#[serde(rename = "attribute")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute: Option<String>,
#[serde(rename = "operator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operator: Option<String>,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Run {
#[serde(rename = "appUpload")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_upload: Option<String>,
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "billingMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub billing_method: Option<String>,
#[serde(rename = "completedJobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completed_jobs: Option<i64>,
#[serde(rename = "counters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub counters: Option<Counters>,
#[serde(rename = "created")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created: Option<f64>,
#[serde(rename = "customerArtifactPaths")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_artifact_paths: Option<CustomerArtifactPaths>,
#[serde(rename = "deviceMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_minutes: Option<DeviceMinutes>,
#[serde(rename = "devicePoolArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_pool_arn: Option<String>,
#[serde(rename = "deviceSelectionResult")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_selection_result: Option<DeviceSelectionResult>,
#[serde(rename = "eventCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_count: Option<i64>,
#[serde(rename = "jobTimeoutMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_timeout_minutes: Option<i64>,
#[serde(rename = "locale")]
#[serde(skip_serializing_if = "Option::is_none")]
pub locale: Option<String>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<Location>,
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "networkProfile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_profile: Option<NetworkProfile>,
#[serde(rename = "parsingResultUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parsing_result_url: Option<String>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "radios")]
#[serde(skip_serializing_if = "Option::is_none")]
pub radios: Option<Radios>,
#[serde(rename = "result")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result: Option<String>,
#[serde(rename = "resultCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result_code: Option<String>,
#[serde(rename = "seed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub seed: Option<i64>,
#[serde(rename = "skipAppResign")]
#[serde(skip_serializing_if = "Option::is_none")]
pub skip_app_resign: Option<bool>,
#[serde(rename = "started")]
#[serde(skip_serializing_if = "Option::is_none")]
pub started: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "stopped")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stopped: Option<f64>,
#[serde(rename = "testSpecArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_spec_arn: Option<String>,
#[serde(rename = "totalJobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total_jobs: Option<i64>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "webUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub web_url: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Sample {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "url")]
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ScheduleRunConfiguration {
#[serde(rename = "auxiliaryApps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auxiliary_apps: Option<Vec<String>>,
#[serde(rename = "billingMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub billing_method: Option<String>,
#[serde(rename = "customerArtifactPaths")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_artifact_paths: Option<CustomerArtifactPaths>,
#[serde(rename = "extraDataPackageArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extra_data_package_arn: Option<String>,
#[serde(rename = "locale")]
#[serde(skip_serializing_if = "Option::is_none")]
pub locale: Option<String>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<Location>,
#[serde(rename = "networkProfileArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_profile_arn: Option<String>,
#[serde(rename = "radios")]
#[serde(skip_serializing_if = "Option::is_none")]
pub radios: Option<Radios>,
#[serde(rename = "vpceConfigurationArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpce_configuration_arns: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ScheduleRunRequest {
#[serde(rename = "appArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_arn: Option<String>,
#[serde(rename = "configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<ScheduleRunConfiguration>,
#[serde(rename = "devicePoolArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_pool_arn: Option<String>,
#[serde(rename = "deviceSelectionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_selection_configuration: Option<DeviceSelectionConfiguration>,
#[serde(rename = "executionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub execution_configuration: Option<ExecutionConfiguration>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "projectArn")]
pub project_arn: String,
#[serde(rename = "test")]
pub test: ScheduleRunTest,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ScheduleRunResult {
#[serde(rename = "run")]
#[serde(skip_serializing_if = "Option::is_none")]
pub run: Option<Run>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ScheduleRunTest {
#[serde(rename = "filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<String>,
#[serde(rename = "parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "testPackageArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_package_arn: Option<String>,
#[serde(rename = "testSpecArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_spec_arn: Option<String>,
#[serde(rename = "type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopJobRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopJobResult {
#[serde(rename = "job")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job: Option<Job>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopRemoteAccessSessionRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopRemoteAccessSessionResult {
#[serde(rename = "remoteAccessSession")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_access_session: Option<RemoteAccessSession>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopRunRequest {
#[serde(rename = "arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopRunResult {
#[serde(rename = "run")]
#[serde(skip_serializing_if = "Option::is_none")]
pub run: Option<Run>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Suite {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "counters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub counters: Option<Counters>,
#[serde(rename = "created")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created: Option<f64>,
#[serde(rename = "deviceMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_minutes: Option<DeviceMinutes>,
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "result")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result: Option<String>,
#[serde(rename = "started")]
#[serde(skip_serializing_if = "Option::is_none")]
pub started: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "stopped")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stopped: Option<f64>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Test {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "counters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub counters: Option<Counters>,
#[serde(rename = "created")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created: Option<f64>,
#[serde(rename = "deviceMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_minutes: Option<DeviceMinutes>,
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "result")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result: Option<String>,
#[serde(rename = "started")]
#[serde(skip_serializing_if = "Option::is_none")]
pub started: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "stopped")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stopped: Option<f64>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TestGridProject {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "created")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created: Option<f64>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TestGridSession {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "billingMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub billing_minutes: Option<f64>,
#[serde(rename = "created")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created: Option<f64>,
#[serde(rename = "ended")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ended: Option<f64>,
#[serde(rename = "seleniumProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub selenium_properties: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TestGridSessionAction {
#[serde(rename = "action")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action: Option<String>,
#[serde(rename = "duration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub duration: Option<i64>,
#[serde(rename = "requestMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_method: Option<String>,
#[serde(rename = "started")]
#[serde(skip_serializing_if = "Option::is_none")]
pub started: Option<f64>,
#[serde(rename = "statusCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_code: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TestGridSessionArtifact {
#[serde(rename = "filename")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filename: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "url")]
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TrialMinutes {
#[serde(rename = "remaining")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remaining: Option<f64>,
#[serde(rename = "total")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UniqueProblem {
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "problems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub problems: Option<Vec<Problem>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDeviceInstanceRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "labels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub labels: Option<Vec<String>>,
#[serde(rename = "profileArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub profile_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDeviceInstanceResult {
#[serde(rename = "deviceInstance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_instance: Option<DeviceInstance>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDevicePoolRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "clearMaxDevices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub clear_max_devices: Option<bool>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "maxDevices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_devices: Option<i64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "rules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rules: Option<Vec<Rule>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDevicePoolResult {
#[serde(rename = "devicePool")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_pool: Option<DevicePool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateInstanceProfileRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "excludeAppPackagesFromCleanup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclude_app_packages_from_cleanup: Option<Vec<String>>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "packageCleanup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_cleanup: Option<bool>,
#[serde(rename = "rebootAfterUse")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reboot_after_use: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateInstanceProfileResult {
#[serde(rename = "instanceProfile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_profile: Option<InstanceProfile>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateNetworkProfileRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "downlinkBandwidthBits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub downlink_bandwidth_bits: Option<i64>,
#[serde(rename = "downlinkDelayMs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub downlink_delay_ms: Option<i64>,
#[serde(rename = "downlinkJitterMs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub downlink_jitter_ms: Option<i64>,
#[serde(rename = "downlinkLossPercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub downlink_loss_percent: Option<i64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "uplinkBandwidthBits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uplink_bandwidth_bits: Option<i64>,
#[serde(rename = "uplinkDelayMs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uplink_delay_ms: Option<i64>,
#[serde(rename = "uplinkJitterMs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uplink_jitter_ms: Option<i64>,
#[serde(rename = "uplinkLossPercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uplink_loss_percent: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateNetworkProfileResult {
#[serde(rename = "networkProfile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_profile: Option<NetworkProfile>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateProjectRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "defaultJobTimeoutMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_job_timeout_minutes: Option<i64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateProjectResult {
#[serde(rename = "project")]
#[serde(skip_serializing_if = "Option::is_none")]
pub project: Option<Project>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateTestGridProjectRequest {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "projectArn")]
pub project_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateTestGridProjectResult {
#[serde(rename = "testGridProject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_grid_project: Option<TestGridProject>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateUploadRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "contentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_type: Option<String>,
#[serde(rename = "editContent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub edit_content: Option<bool>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateUploadResult {
#[serde(rename = "upload")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upload: Option<Upload>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateVPCEConfigurationRequest {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "serviceDnsName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_dns_name: Option<String>,
#[serde(rename = "vpceConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpce_configuration_description: Option<String>,
#[serde(rename = "vpceConfigurationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpce_configuration_name: Option<String>,
#[serde(rename = "vpceServiceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpce_service_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateVPCEConfigurationResult {
#[serde(rename = "vpceConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpce_configuration: Option<VPCEConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Upload {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "category")]
#[serde(skip_serializing_if = "Option::is_none")]
pub category: Option<String>,
#[serde(rename = "contentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_type: Option<String>,
#[serde(rename = "created")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created: Option<f64>,
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "metadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "url")]
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VPCEConfiguration {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "serviceDnsName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_dns_name: Option<String>,
#[serde(rename = "vpceConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpce_configuration_description: Option<String>,
#[serde(rename = "vpceConfigurationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpce_configuration_name: Option<String>,
#[serde(rename = "vpceServiceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpce_service_name: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum CreateDevicePoolError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl CreateDevicePoolError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDevicePoolError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(CreateDevicePoolError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateDevicePoolError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateDevicePoolError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(CreateDevicePoolError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDevicePoolError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDevicePoolError::Argument(ref cause) => write!(f, "{}", cause),
CreateDevicePoolError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateDevicePoolError::NotFound(ref cause) => write!(f, "{}", cause),
CreateDevicePoolError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDevicePoolError {}
#[derive(Debug, PartialEq)]
pub enum CreateInstanceProfileError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl CreateInstanceProfileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateInstanceProfileError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(CreateInstanceProfileError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateInstanceProfileError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateInstanceProfileError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(CreateInstanceProfileError::ServiceAccount(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateInstanceProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateInstanceProfileError::Argument(ref cause) => write!(f, "{}", cause),
CreateInstanceProfileError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateInstanceProfileError::NotFound(ref cause) => write!(f, "{}", cause),
CreateInstanceProfileError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateInstanceProfileError {}
#[derive(Debug, PartialEq)]
pub enum CreateNetworkProfileError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl CreateNetworkProfileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateNetworkProfileError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(CreateNetworkProfileError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateNetworkProfileError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateNetworkProfileError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(CreateNetworkProfileError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateNetworkProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateNetworkProfileError::Argument(ref cause) => write!(f, "{}", cause),
CreateNetworkProfileError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateNetworkProfileError::NotFound(ref cause) => write!(f, "{}", cause),
CreateNetworkProfileError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateNetworkProfileError {}
#[derive(Debug, PartialEq)]
pub enum CreateProjectError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
TagOperation(String),
}
impl CreateProjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateProjectError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(CreateProjectError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateProjectError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateProjectError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(CreateProjectError::ServiceAccount(err.msg))
}
"TagOperationException" => {
return RusotoError::Service(CreateProjectError::TagOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateProjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateProjectError::Argument(ref cause) => write!(f, "{}", cause),
CreateProjectError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateProjectError::NotFound(ref cause) => write!(f, "{}", cause),
CreateProjectError::ServiceAccount(ref cause) => write!(f, "{}", cause),
CreateProjectError::TagOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateProjectError {}
#[derive(Debug, PartialEq)]
pub enum CreateRemoteAccessSessionError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl CreateRemoteAccessSessionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateRemoteAccessSessionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(CreateRemoteAccessSessionError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateRemoteAccessSessionError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(CreateRemoteAccessSessionError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(CreateRemoteAccessSessionError::ServiceAccount(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateRemoteAccessSessionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateRemoteAccessSessionError::Argument(ref cause) => write!(f, "{}", cause),
CreateRemoteAccessSessionError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateRemoteAccessSessionError::NotFound(ref cause) => write!(f, "{}", cause),
CreateRemoteAccessSessionError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateRemoteAccessSessionError {}
#[derive(Debug, PartialEq)]
pub enum CreateTestGridProjectError {
InternalService(String),
}
impl CreateTestGridProjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTestGridProjectError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(CreateTestGridProjectError::InternalService(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateTestGridProjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateTestGridProjectError::InternalService(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateTestGridProjectError {}
#[derive(Debug, PartialEq)]
pub enum CreateTestGridUrlError {
Argument(String),
InternalService(String),
NotFound(String),
}
impl CreateTestGridUrlError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTestGridUrlError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(CreateTestGridUrlError::Argument(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(CreateTestGridUrlError::InternalService(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateTestGridUrlError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateTestGridUrlError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateTestGridUrlError::Argument(ref cause) => write!(f, "{}", cause),
CreateTestGridUrlError::InternalService(ref cause) => write!(f, "{}", cause),
CreateTestGridUrlError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateTestGridUrlError {}
#[derive(Debug, PartialEq)]
pub enum CreateUploadError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl CreateUploadError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateUploadError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(CreateUploadError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateUploadError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateUploadError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(CreateUploadError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateUploadError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateUploadError::Argument(ref cause) => write!(f, "{}", cause),
CreateUploadError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateUploadError::NotFound(ref cause) => write!(f, "{}", cause),
CreateUploadError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateUploadError {}
#[derive(Debug, PartialEq)]
pub enum CreateVPCEConfigurationError {
Argument(String),
LimitExceeded(String),
ServiceAccount(String),
}
impl CreateVPCEConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateVPCEConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(CreateVPCEConfigurationError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateVPCEConfigurationError::LimitExceeded(
err.msg,
))
}
"ServiceAccountException" => {
return RusotoError::Service(CreateVPCEConfigurationError::ServiceAccount(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateVPCEConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateVPCEConfigurationError::Argument(ref cause) => write!(f, "{}", cause),
CreateVPCEConfigurationError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateVPCEConfigurationError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateVPCEConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDevicePoolError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl DeleteDevicePoolError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDevicePoolError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(DeleteDevicePoolError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteDevicePoolError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteDevicePoolError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(DeleteDevicePoolError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDevicePoolError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDevicePoolError::Argument(ref cause) => write!(f, "{}", cause),
DeleteDevicePoolError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteDevicePoolError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteDevicePoolError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDevicePoolError {}
#[derive(Debug, PartialEq)]
pub enum DeleteInstanceProfileError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl DeleteInstanceProfileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteInstanceProfileError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(DeleteInstanceProfileError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteInstanceProfileError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteInstanceProfileError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(DeleteInstanceProfileError::ServiceAccount(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteInstanceProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteInstanceProfileError::Argument(ref cause) => write!(f, "{}", cause),
DeleteInstanceProfileError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteInstanceProfileError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteInstanceProfileError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteInstanceProfileError {}
#[derive(Debug, PartialEq)]
pub enum DeleteNetworkProfileError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl DeleteNetworkProfileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteNetworkProfileError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(DeleteNetworkProfileError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteNetworkProfileError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteNetworkProfileError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(DeleteNetworkProfileError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteNetworkProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteNetworkProfileError::Argument(ref cause) => write!(f, "{}", cause),
DeleteNetworkProfileError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteNetworkProfileError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteNetworkProfileError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteNetworkProfileError {}
#[derive(Debug, PartialEq)]
pub enum DeleteProjectError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl DeleteProjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteProjectError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(DeleteProjectError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteProjectError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteProjectError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(DeleteProjectError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteProjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteProjectError::Argument(ref cause) => write!(f, "{}", cause),
DeleteProjectError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteProjectError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteProjectError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteProjectError {}
#[derive(Debug, PartialEq)]
pub enum DeleteRemoteAccessSessionError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl DeleteRemoteAccessSessionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteRemoteAccessSessionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(DeleteRemoteAccessSessionError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteRemoteAccessSessionError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(DeleteRemoteAccessSessionError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(DeleteRemoteAccessSessionError::ServiceAccount(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteRemoteAccessSessionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteRemoteAccessSessionError::Argument(ref cause) => write!(f, "{}", cause),
DeleteRemoteAccessSessionError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteRemoteAccessSessionError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteRemoteAccessSessionError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteRemoteAccessSessionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteRunError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl DeleteRunError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteRunError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(DeleteRunError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteRunError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteRunError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(DeleteRunError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteRunError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteRunError::Argument(ref cause) => write!(f, "{}", cause),
DeleteRunError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteRunError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteRunError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteRunError {}
#[derive(Debug, PartialEq)]
pub enum DeleteTestGridProjectError {
Argument(String),
CannotDelete(String),
InternalService(String),
NotFound(String),
}
impl DeleteTestGridProjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTestGridProjectError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(DeleteTestGridProjectError::Argument(err.msg))
}
"CannotDeleteException" => {
return RusotoError::Service(DeleteTestGridProjectError::CannotDelete(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(DeleteTestGridProjectError::InternalService(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(DeleteTestGridProjectError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteTestGridProjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteTestGridProjectError::Argument(ref cause) => write!(f, "{}", cause),
DeleteTestGridProjectError::CannotDelete(ref cause) => write!(f, "{}", cause),
DeleteTestGridProjectError::InternalService(ref cause) => write!(f, "{}", cause),
DeleteTestGridProjectError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteTestGridProjectError {}
#[derive(Debug, PartialEq)]
pub enum DeleteUploadError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl DeleteUploadError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteUploadError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(DeleteUploadError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteUploadError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteUploadError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(DeleteUploadError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteUploadError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteUploadError::Argument(ref cause) => write!(f, "{}", cause),
DeleteUploadError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteUploadError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteUploadError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteUploadError {}
#[derive(Debug, PartialEq)]
pub enum DeleteVPCEConfigurationError {
Argument(String),
InvalidOperation(String),
NotFound(String),
ServiceAccount(String),
}
impl DeleteVPCEConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteVPCEConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(DeleteVPCEConfigurationError::Argument(err.msg))
}
"InvalidOperationException" => {
return RusotoError::Service(DeleteVPCEConfigurationError::InvalidOperation(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(DeleteVPCEConfigurationError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(DeleteVPCEConfigurationError::ServiceAccount(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteVPCEConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteVPCEConfigurationError::Argument(ref cause) => write!(f, "{}", cause),
DeleteVPCEConfigurationError::InvalidOperation(ref cause) => write!(f, "{}", cause),
DeleteVPCEConfigurationError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteVPCEConfigurationError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteVPCEConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum GetAccountSettingsError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl GetAccountSettingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAccountSettingsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(GetAccountSettingsError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetAccountSettingsError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetAccountSettingsError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(GetAccountSettingsError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAccountSettingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAccountSettingsError::Argument(ref cause) => write!(f, "{}", cause),
GetAccountSettingsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetAccountSettingsError::NotFound(ref cause) => write!(f, "{}", cause),
GetAccountSettingsError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetAccountSettingsError {}
#[derive(Debug, PartialEq)]
pub enum GetDeviceError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl GetDeviceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDeviceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(GetDeviceError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetDeviceError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetDeviceError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(GetDeviceError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDeviceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDeviceError::Argument(ref cause) => write!(f, "{}", cause),
GetDeviceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetDeviceError::NotFound(ref cause) => write!(f, "{}", cause),
GetDeviceError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDeviceError {}
#[derive(Debug, PartialEq)]
pub enum GetDeviceInstanceError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl GetDeviceInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDeviceInstanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(GetDeviceInstanceError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetDeviceInstanceError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetDeviceInstanceError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(GetDeviceInstanceError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDeviceInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDeviceInstanceError::Argument(ref cause) => write!(f, "{}", cause),
GetDeviceInstanceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetDeviceInstanceError::NotFound(ref cause) => write!(f, "{}", cause),
GetDeviceInstanceError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDeviceInstanceError {}
#[derive(Debug, PartialEq)]
pub enum GetDevicePoolError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl GetDevicePoolError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDevicePoolError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(GetDevicePoolError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetDevicePoolError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetDevicePoolError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(GetDevicePoolError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDevicePoolError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDevicePoolError::Argument(ref cause) => write!(f, "{}", cause),
GetDevicePoolError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetDevicePoolError::NotFound(ref cause) => write!(f, "{}", cause),
GetDevicePoolError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDevicePoolError {}
#[derive(Debug, PartialEq)]
pub enum GetDevicePoolCompatibilityError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl GetDevicePoolCompatibilityError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetDevicePoolCompatibilityError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(GetDevicePoolCompatibilityError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetDevicePoolCompatibilityError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetDevicePoolCompatibilityError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(GetDevicePoolCompatibilityError::ServiceAccount(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDevicePoolCompatibilityError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDevicePoolCompatibilityError::Argument(ref cause) => write!(f, "{}", cause),
GetDevicePoolCompatibilityError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetDevicePoolCompatibilityError::NotFound(ref cause) => write!(f, "{}", cause),
GetDevicePoolCompatibilityError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDevicePoolCompatibilityError {}
#[derive(Debug, PartialEq)]
pub enum GetInstanceProfileError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl GetInstanceProfileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetInstanceProfileError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(GetInstanceProfileError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetInstanceProfileError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetInstanceProfileError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(GetInstanceProfileError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetInstanceProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetInstanceProfileError::Argument(ref cause) => write!(f, "{}", cause),
GetInstanceProfileError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetInstanceProfileError::NotFound(ref cause) => write!(f, "{}", cause),
GetInstanceProfileError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetInstanceProfileError {}
#[derive(Debug, PartialEq)]
pub enum GetJobError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl GetJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => return RusotoError::Service(GetJobError::Argument(err.msg)),
"LimitExceededException" => {
return RusotoError::Service(GetJobError::LimitExceeded(err.msg))
}
"NotFoundException" => return RusotoError::Service(GetJobError::NotFound(err.msg)),
"ServiceAccountException" => {
return RusotoError::Service(GetJobError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetJobError::Argument(ref cause) => write!(f, "{}", cause),
GetJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetJobError::NotFound(ref cause) => write!(f, "{}", cause),
GetJobError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetJobError {}
#[derive(Debug, PartialEq)]
pub enum GetNetworkProfileError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl GetNetworkProfileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetNetworkProfileError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(GetNetworkProfileError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetNetworkProfileError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetNetworkProfileError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(GetNetworkProfileError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetNetworkProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetNetworkProfileError::Argument(ref cause) => write!(f, "{}", cause),
GetNetworkProfileError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetNetworkProfileError::NotFound(ref cause) => write!(f, "{}", cause),
GetNetworkProfileError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetNetworkProfileError {}
#[derive(Debug, PartialEq)]
pub enum GetOfferingStatusError {
Argument(String),
LimitExceeded(String),
NotEligible(String),
NotFound(String),
ServiceAccount(String),
}
impl GetOfferingStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetOfferingStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(GetOfferingStatusError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetOfferingStatusError::LimitExceeded(err.msg))
}
"NotEligibleException" => {
return RusotoError::Service(GetOfferingStatusError::NotEligible(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetOfferingStatusError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(GetOfferingStatusError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetOfferingStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetOfferingStatusError::Argument(ref cause) => write!(f, "{}", cause),
GetOfferingStatusError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetOfferingStatusError::NotEligible(ref cause) => write!(f, "{}", cause),
GetOfferingStatusError::NotFound(ref cause) => write!(f, "{}", cause),
GetOfferingStatusError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetOfferingStatusError {}
#[derive(Debug, PartialEq)]
pub enum GetProjectError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl GetProjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetProjectError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(GetProjectError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetProjectError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetProjectError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(GetProjectError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetProjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetProjectError::Argument(ref cause) => write!(f, "{}", cause),
GetProjectError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetProjectError::NotFound(ref cause) => write!(f, "{}", cause),
GetProjectError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetProjectError {}
#[derive(Debug, PartialEq)]
pub enum GetRemoteAccessSessionError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl GetRemoteAccessSessionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetRemoteAccessSessionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(GetRemoteAccessSessionError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetRemoteAccessSessionError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetRemoteAccessSessionError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(GetRemoteAccessSessionError::ServiceAccount(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRemoteAccessSessionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRemoteAccessSessionError::Argument(ref cause) => write!(f, "{}", cause),
GetRemoteAccessSessionError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetRemoteAccessSessionError::NotFound(ref cause) => write!(f, "{}", cause),
GetRemoteAccessSessionError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetRemoteAccessSessionError {}
#[derive(Debug, PartialEq)]
pub enum GetRunError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl GetRunError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetRunError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => return RusotoError::Service(GetRunError::Argument(err.msg)),
"LimitExceededException" => {
return RusotoError::Service(GetRunError::LimitExceeded(err.msg))
}
"NotFoundException" => return RusotoError::Service(GetRunError::NotFound(err.msg)),
"ServiceAccountException" => {
return RusotoError::Service(GetRunError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRunError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRunError::Argument(ref cause) => write!(f, "{}", cause),
GetRunError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetRunError::NotFound(ref cause) => write!(f, "{}", cause),
GetRunError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetRunError {}
#[derive(Debug, PartialEq)]
pub enum GetSuiteError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl GetSuiteError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetSuiteError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(GetSuiteError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetSuiteError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetSuiteError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(GetSuiteError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetSuiteError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSuiteError::Argument(ref cause) => write!(f, "{}", cause),
GetSuiteError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetSuiteError::NotFound(ref cause) => write!(f, "{}", cause),
GetSuiteError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSuiteError {}
#[derive(Debug, PartialEq)]
pub enum GetTestError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl GetTestError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetTestError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(GetTestError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetTestError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetTestError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(GetTestError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetTestError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetTestError::Argument(ref cause) => write!(f, "{}", cause),
GetTestError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetTestError::NotFound(ref cause) => write!(f, "{}", cause),
GetTestError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetTestError {}
#[derive(Debug, PartialEq)]
pub enum GetTestGridProjectError {
Argument(String),
InternalService(String),
NotFound(String),
}
impl GetTestGridProjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetTestGridProjectError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(GetTestGridProjectError::Argument(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(GetTestGridProjectError::InternalService(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetTestGridProjectError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetTestGridProjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetTestGridProjectError::Argument(ref cause) => write!(f, "{}", cause),
GetTestGridProjectError::InternalService(ref cause) => write!(f, "{}", cause),
GetTestGridProjectError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetTestGridProjectError {}
#[derive(Debug, PartialEq)]
pub enum GetTestGridSessionError {
Argument(String),
InternalService(String),
NotFound(String),
}
impl GetTestGridSessionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetTestGridSessionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(GetTestGridSessionError::Argument(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(GetTestGridSessionError::InternalService(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetTestGridSessionError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetTestGridSessionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetTestGridSessionError::Argument(ref cause) => write!(f, "{}", cause),
GetTestGridSessionError::InternalService(ref cause) => write!(f, "{}", cause),
GetTestGridSessionError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetTestGridSessionError {}
#[derive(Debug, PartialEq)]
pub enum GetUploadError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl GetUploadError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetUploadError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(GetUploadError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetUploadError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetUploadError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(GetUploadError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetUploadError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetUploadError::Argument(ref cause) => write!(f, "{}", cause),
GetUploadError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetUploadError::NotFound(ref cause) => write!(f, "{}", cause),
GetUploadError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetUploadError {}
#[derive(Debug, PartialEq)]
pub enum GetVPCEConfigurationError {
Argument(String),
NotFound(String),
ServiceAccount(String),
}
impl GetVPCEConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetVPCEConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(GetVPCEConfigurationError::Argument(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetVPCEConfigurationError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(GetVPCEConfigurationError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetVPCEConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetVPCEConfigurationError::Argument(ref cause) => write!(f, "{}", cause),
GetVPCEConfigurationError::NotFound(ref cause) => write!(f, "{}", cause),
GetVPCEConfigurationError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetVPCEConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum InstallToRemoteAccessSessionError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl InstallToRemoteAccessSessionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<InstallToRemoteAccessSessionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(InstallToRemoteAccessSessionError::Argument(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(InstallToRemoteAccessSessionError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(InstallToRemoteAccessSessionError::NotFound(
err.msg,
))
}
"ServiceAccountException" => {
return RusotoError::Service(InstallToRemoteAccessSessionError::ServiceAccount(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for InstallToRemoteAccessSessionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
InstallToRemoteAccessSessionError::Argument(ref cause) => write!(f, "{}", cause),
InstallToRemoteAccessSessionError::LimitExceeded(ref cause) => write!(f, "{}", cause),
InstallToRemoteAccessSessionError::NotFound(ref cause) => write!(f, "{}", cause),
InstallToRemoteAccessSessionError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for InstallToRemoteAccessSessionError {}
#[derive(Debug, PartialEq)]
pub enum ListArtifactsError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl ListArtifactsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListArtifactsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListArtifactsError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListArtifactsError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListArtifactsError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListArtifactsError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListArtifactsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListArtifactsError::Argument(ref cause) => write!(f, "{}", cause),
ListArtifactsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListArtifactsError::NotFound(ref cause) => write!(f, "{}", cause),
ListArtifactsError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListArtifactsError {}
#[derive(Debug, PartialEq)]
pub enum ListDeviceInstancesError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl ListDeviceInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDeviceInstancesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListDeviceInstancesError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListDeviceInstancesError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListDeviceInstancesError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListDeviceInstancesError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDeviceInstancesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDeviceInstancesError::Argument(ref cause) => write!(f, "{}", cause),
ListDeviceInstancesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListDeviceInstancesError::NotFound(ref cause) => write!(f, "{}", cause),
ListDeviceInstancesError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDeviceInstancesError {}
#[derive(Debug, PartialEq)]
pub enum ListDevicePoolsError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl ListDevicePoolsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDevicePoolsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListDevicePoolsError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListDevicePoolsError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListDevicePoolsError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListDevicePoolsError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDevicePoolsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDevicePoolsError::Argument(ref cause) => write!(f, "{}", cause),
ListDevicePoolsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListDevicePoolsError::NotFound(ref cause) => write!(f, "{}", cause),
ListDevicePoolsError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDevicePoolsError {}
#[derive(Debug, PartialEq)]
pub enum ListDevicesError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl ListDevicesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDevicesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListDevicesError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListDevicesError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListDevicesError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListDevicesError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDevicesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDevicesError::Argument(ref cause) => write!(f, "{}", cause),
ListDevicesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListDevicesError::NotFound(ref cause) => write!(f, "{}", cause),
ListDevicesError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDevicesError {}
#[derive(Debug, PartialEq)]
pub enum ListInstanceProfilesError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl ListInstanceProfilesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListInstanceProfilesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListInstanceProfilesError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListInstanceProfilesError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListInstanceProfilesError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListInstanceProfilesError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListInstanceProfilesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListInstanceProfilesError::Argument(ref cause) => write!(f, "{}", cause),
ListInstanceProfilesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListInstanceProfilesError::NotFound(ref cause) => write!(f, "{}", cause),
ListInstanceProfilesError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListInstanceProfilesError {}
#[derive(Debug, PartialEq)]
pub enum ListJobsError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl ListJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListJobsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListJobsError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListJobsError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListJobsError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListJobsError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListJobsError::Argument(ref cause) => write!(f, "{}", cause),
ListJobsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListJobsError::NotFound(ref cause) => write!(f, "{}", cause),
ListJobsError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListNetworkProfilesError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl ListNetworkProfilesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListNetworkProfilesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListNetworkProfilesError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListNetworkProfilesError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListNetworkProfilesError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListNetworkProfilesError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListNetworkProfilesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListNetworkProfilesError::Argument(ref cause) => write!(f, "{}", cause),
ListNetworkProfilesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListNetworkProfilesError::NotFound(ref cause) => write!(f, "{}", cause),
ListNetworkProfilesError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListNetworkProfilesError {}
#[derive(Debug, PartialEq)]
pub enum ListOfferingPromotionsError {
Argument(String),
LimitExceeded(String),
NotEligible(String),
NotFound(String),
ServiceAccount(String),
}
impl ListOfferingPromotionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListOfferingPromotionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListOfferingPromotionsError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListOfferingPromotionsError::LimitExceeded(
err.msg,
))
}
"NotEligibleException" => {
return RusotoError::Service(ListOfferingPromotionsError::NotEligible(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListOfferingPromotionsError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListOfferingPromotionsError::ServiceAccount(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListOfferingPromotionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListOfferingPromotionsError::Argument(ref cause) => write!(f, "{}", cause),
ListOfferingPromotionsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListOfferingPromotionsError::NotEligible(ref cause) => write!(f, "{}", cause),
ListOfferingPromotionsError::NotFound(ref cause) => write!(f, "{}", cause),
ListOfferingPromotionsError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListOfferingPromotionsError {}
#[derive(Debug, PartialEq)]
pub enum ListOfferingTransactionsError {
Argument(String),
LimitExceeded(String),
NotEligible(String),
NotFound(String),
ServiceAccount(String),
}
impl ListOfferingTransactionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListOfferingTransactionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListOfferingTransactionsError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListOfferingTransactionsError::LimitExceeded(
err.msg,
))
}
"NotEligibleException" => {
return RusotoError::Service(ListOfferingTransactionsError::NotEligible(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(ListOfferingTransactionsError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListOfferingTransactionsError::ServiceAccount(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListOfferingTransactionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListOfferingTransactionsError::Argument(ref cause) => write!(f, "{}", cause),
ListOfferingTransactionsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListOfferingTransactionsError::NotEligible(ref cause) => write!(f, "{}", cause),
ListOfferingTransactionsError::NotFound(ref cause) => write!(f, "{}", cause),
ListOfferingTransactionsError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListOfferingTransactionsError {}
#[derive(Debug, PartialEq)]
pub enum ListOfferingsError {
Argument(String),
LimitExceeded(String),
NotEligible(String),
NotFound(String),
ServiceAccount(String),
}
impl ListOfferingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListOfferingsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListOfferingsError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListOfferingsError::LimitExceeded(err.msg))
}
"NotEligibleException" => {
return RusotoError::Service(ListOfferingsError::NotEligible(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListOfferingsError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListOfferingsError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListOfferingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListOfferingsError::Argument(ref cause) => write!(f, "{}", cause),
ListOfferingsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListOfferingsError::NotEligible(ref cause) => write!(f, "{}", cause),
ListOfferingsError::NotFound(ref cause) => write!(f, "{}", cause),
ListOfferingsError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListOfferingsError {}
#[derive(Debug, PartialEq)]
pub enum ListProjectsError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl ListProjectsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListProjectsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListProjectsError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListProjectsError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListProjectsError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListProjectsError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListProjectsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListProjectsError::Argument(ref cause) => write!(f, "{}", cause),
ListProjectsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListProjectsError::NotFound(ref cause) => write!(f, "{}", cause),
ListProjectsError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListProjectsError {}
#[derive(Debug, PartialEq)]
pub enum ListRemoteAccessSessionsError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl ListRemoteAccessSessionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListRemoteAccessSessionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListRemoteAccessSessionsError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListRemoteAccessSessionsError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(ListRemoteAccessSessionsError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListRemoteAccessSessionsError::ServiceAccount(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRemoteAccessSessionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRemoteAccessSessionsError::Argument(ref cause) => write!(f, "{}", cause),
ListRemoteAccessSessionsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListRemoteAccessSessionsError::NotFound(ref cause) => write!(f, "{}", cause),
ListRemoteAccessSessionsError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListRemoteAccessSessionsError {}
#[derive(Debug, PartialEq)]
pub enum ListRunsError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl ListRunsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListRunsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListRunsError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListRunsError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListRunsError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListRunsError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRunsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRunsError::Argument(ref cause) => write!(f, "{}", cause),
ListRunsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListRunsError::NotFound(ref cause) => write!(f, "{}", cause),
ListRunsError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListRunsError {}
#[derive(Debug, PartialEq)]
pub enum ListSamplesError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl ListSamplesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSamplesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListSamplesError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListSamplesError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListSamplesError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListSamplesError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListSamplesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListSamplesError::Argument(ref cause) => write!(f, "{}", cause),
ListSamplesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListSamplesError::NotFound(ref cause) => write!(f, "{}", cause),
ListSamplesError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListSamplesError {}
#[derive(Debug, PartialEq)]
pub enum ListSuitesError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl ListSuitesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSuitesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListSuitesError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListSuitesError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListSuitesError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListSuitesError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListSuitesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListSuitesError::Argument(ref cause) => write!(f, "{}", cause),
ListSuitesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListSuitesError::NotFound(ref cause) => write!(f, "{}", cause),
ListSuitesError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListSuitesError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
Argument(String),
NotFound(String),
TagOperation(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListTagsForResourceError::Argument(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::NotFound(err.msg))
}
"TagOperationException" => {
return RusotoError::Service(ListTagsForResourceError::TagOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::Argument(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::NotFound(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::TagOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListTestGridProjectsError {
Argument(String),
InternalService(String),
}
impl ListTestGridProjectsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTestGridProjectsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListTestGridProjectsError::Argument(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(ListTestGridProjectsError::InternalService(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTestGridProjectsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTestGridProjectsError::Argument(ref cause) => write!(f, "{}", cause),
ListTestGridProjectsError::InternalService(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTestGridProjectsError {}
#[derive(Debug, PartialEq)]
pub enum ListTestGridSessionActionsError {
Argument(String),
InternalService(String),
NotFound(String),
}
impl ListTestGridSessionActionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListTestGridSessionActionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListTestGridSessionActionsError::Argument(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(ListTestGridSessionActionsError::InternalService(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(ListTestGridSessionActionsError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTestGridSessionActionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTestGridSessionActionsError::Argument(ref cause) => write!(f, "{}", cause),
ListTestGridSessionActionsError::InternalService(ref cause) => write!(f, "{}", cause),
ListTestGridSessionActionsError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTestGridSessionActionsError {}
#[derive(Debug, PartialEq)]
pub enum ListTestGridSessionArtifactsError {
Argument(String),
InternalService(String),
NotFound(String),
}
impl ListTestGridSessionArtifactsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListTestGridSessionArtifactsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListTestGridSessionArtifactsError::Argument(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(
ListTestGridSessionArtifactsError::InternalService(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(ListTestGridSessionArtifactsError::NotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTestGridSessionArtifactsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTestGridSessionArtifactsError::Argument(ref cause) => write!(f, "{}", cause),
ListTestGridSessionArtifactsError::InternalService(ref cause) => write!(f, "{}", cause),
ListTestGridSessionArtifactsError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTestGridSessionArtifactsError {}
#[derive(Debug, PartialEq)]
pub enum ListTestGridSessionsError {
Argument(String),
InternalService(String),
NotFound(String),
}
impl ListTestGridSessionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTestGridSessionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListTestGridSessionsError::Argument(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(ListTestGridSessionsError::InternalService(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(ListTestGridSessionsError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTestGridSessionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTestGridSessionsError::Argument(ref cause) => write!(f, "{}", cause),
ListTestGridSessionsError::InternalService(ref cause) => write!(f, "{}", cause),
ListTestGridSessionsError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTestGridSessionsError {}
#[derive(Debug, PartialEq)]
pub enum ListTestsError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl ListTestsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTestsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListTestsError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListTestsError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListTestsError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListTestsError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTestsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTestsError::Argument(ref cause) => write!(f, "{}", cause),
ListTestsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListTestsError::NotFound(ref cause) => write!(f, "{}", cause),
ListTestsError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTestsError {}
#[derive(Debug, PartialEq)]
pub enum ListUniqueProblemsError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl ListUniqueProblemsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListUniqueProblemsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListUniqueProblemsError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListUniqueProblemsError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListUniqueProblemsError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListUniqueProblemsError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListUniqueProblemsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListUniqueProblemsError::Argument(ref cause) => write!(f, "{}", cause),
ListUniqueProblemsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListUniqueProblemsError::NotFound(ref cause) => write!(f, "{}", cause),
ListUniqueProblemsError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListUniqueProblemsError {}
#[derive(Debug, PartialEq)]
pub enum ListUploadsError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl ListUploadsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListUploadsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListUploadsError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListUploadsError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListUploadsError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListUploadsError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListUploadsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListUploadsError::Argument(ref cause) => write!(f, "{}", cause),
ListUploadsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListUploadsError::NotFound(ref cause) => write!(f, "{}", cause),
ListUploadsError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListUploadsError {}
#[derive(Debug, PartialEq)]
pub enum ListVPCEConfigurationsError {
Argument(String),
ServiceAccount(String),
}
impl ListVPCEConfigurationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListVPCEConfigurationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ListVPCEConfigurationsError::Argument(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ListVPCEConfigurationsError::ServiceAccount(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListVPCEConfigurationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListVPCEConfigurationsError::Argument(ref cause) => write!(f, "{}", cause),
ListVPCEConfigurationsError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListVPCEConfigurationsError {}
#[derive(Debug, PartialEq)]
pub enum PurchaseOfferingError {
Argument(String),
LimitExceeded(String),
NotEligible(String),
NotFound(String),
ServiceAccount(String),
}
impl PurchaseOfferingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PurchaseOfferingError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(PurchaseOfferingError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(PurchaseOfferingError::LimitExceeded(err.msg))
}
"NotEligibleException" => {
return RusotoError::Service(PurchaseOfferingError::NotEligible(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(PurchaseOfferingError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(PurchaseOfferingError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PurchaseOfferingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PurchaseOfferingError::Argument(ref cause) => write!(f, "{}", cause),
PurchaseOfferingError::LimitExceeded(ref cause) => write!(f, "{}", cause),
PurchaseOfferingError::NotEligible(ref cause) => write!(f, "{}", cause),
PurchaseOfferingError::NotFound(ref cause) => write!(f, "{}", cause),
PurchaseOfferingError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PurchaseOfferingError {}
#[derive(Debug, PartialEq)]
pub enum RenewOfferingError {
Argument(String),
LimitExceeded(String),
NotEligible(String),
NotFound(String),
ServiceAccount(String),
}
impl RenewOfferingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RenewOfferingError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(RenewOfferingError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(RenewOfferingError::LimitExceeded(err.msg))
}
"NotEligibleException" => {
return RusotoError::Service(RenewOfferingError::NotEligible(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(RenewOfferingError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(RenewOfferingError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RenewOfferingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RenewOfferingError::Argument(ref cause) => write!(f, "{}", cause),
RenewOfferingError::LimitExceeded(ref cause) => write!(f, "{}", cause),
RenewOfferingError::NotEligible(ref cause) => write!(f, "{}", cause),
RenewOfferingError::NotFound(ref cause) => write!(f, "{}", cause),
RenewOfferingError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RenewOfferingError {}
#[derive(Debug, PartialEq)]
pub enum ScheduleRunError {
Argument(String),
Idempotency(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl ScheduleRunError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ScheduleRunError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(ScheduleRunError::Argument(err.msg))
}
"IdempotencyException" => {
return RusotoError::Service(ScheduleRunError::Idempotency(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ScheduleRunError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ScheduleRunError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(ScheduleRunError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ScheduleRunError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ScheduleRunError::Argument(ref cause) => write!(f, "{}", cause),
ScheduleRunError::Idempotency(ref cause) => write!(f, "{}", cause),
ScheduleRunError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ScheduleRunError::NotFound(ref cause) => write!(f, "{}", cause),
ScheduleRunError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ScheduleRunError {}
#[derive(Debug, PartialEq)]
pub enum StopJobError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl StopJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(StopJobError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(StopJobError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(StopJobError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(StopJobError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopJobError::Argument(ref cause) => write!(f, "{}", cause),
StopJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
StopJobError::NotFound(ref cause) => write!(f, "{}", cause),
StopJobError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopJobError {}
#[derive(Debug, PartialEq)]
pub enum StopRemoteAccessSessionError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl StopRemoteAccessSessionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopRemoteAccessSessionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(StopRemoteAccessSessionError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(StopRemoteAccessSessionError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(StopRemoteAccessSessionError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(StopRemoteAccessSessionError::ServiceAccount(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopRemoteAccessSessionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopRemoteAccessSessionError::Argument(ref cause) => write!(f, "{}", cause),
StopRemoteAccessSessionError::LimitExceeded(ref cause) => write!(f, "{}", cause),
StopRemoteAccessSessionError::NotFound(ref cause) => write!(f, "{}", cause),
StopRemoteAccessSessionError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopRemoteAccessSessionError {}
#[derive(Debug, PartialEq)]
pub enum StopRunError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl StopRunError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopRunError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(StopRunError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(StopRunError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(StopRunError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(StopRunError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopRunError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopRunError::Argument(ref cause) => write!(f, "{}", cause),
StopRunError::LimitExceeded(ref cause) => write!(f, "{}", cause),
StopRunError::NotFound(ref cause) => write!(f, "{}", cause),
StopRunError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopRunError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
Argument(String),
NotFound(String),
TagOperation(String),
TagPolicy(String),
TooManyTags(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(TagResourceError::Argument(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(TagResourceError::NotFound(err.msg))
}
"TagOperationException" => {
return RusotoError::Service(TagResourceError::TagOperation(err.msg))
}
"TagPolicyException" => {
return RusotoError::Service(TagResourceError::TagPolicy(err.msg))
}
"TooManyTagsException" => {
return RusotoError::Service(TagResourceError::TooManyTags(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::Argument(ref cause) => write!(f, "{}", cause),
TagResourceError::NotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::TagOperation(ref cause) => write!(f, "{}", cause),
TagResourceError::TagPolicy(ref cause) => write!(f, "{}", cause),
TagResourceError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
Argument(String),
NotFound(String),
TagOperation(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(UntagResourceError::Argument(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UntagResourceError::NotFound(err.msg))
}
"TagOperationException" => {
return RusotoError::Service(UntagResourceError::TagOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::Argument(ref cause) => write!(f, "{}", cause),
UntagResourceError::NotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::TagOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDeviceInstanceError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl UpdateDeviceInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDeviceInstanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(UpdateDeviceInstanceError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateDeviceInstanceError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateDeviceInstanceError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(UpdateDeviceInstanceError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDeviceInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDeviceInstanceError::Argument(ref cause) => write!(f, "{}", cause),
UpdateDeviceInstanceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateDeviceInstanceError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateDeviceInstanceError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDeviceInstanceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDevicePoolError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl UpdateDevicePoolError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDevicePoolError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(UpdateDevicePoolError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateDevicePoolError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateDevicePoolError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(UpdateDevicePoolError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDevicePoolError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDevicePoolError::Argument(ref cause) => write!(f, "{}", cause),
UpdateDevicePoolError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateDevicePoolError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateDevicePoolError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDevicePoolError {}
#[derive(Debug, PartialEq)]
pub enum UpdateInstanceProfileError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl UpdateInstanceProfileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateInstanceProfileError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(UpdateInstanceProfileError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateInstanceProfileError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateInstanceProfileError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(UpdateInstanceProfileError::ServiceAccount(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateInstanceProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateInstanceProfileError::Argument(ref cause) => write!(f, "{}", cause),
UpdateInstanceProfileError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateInstanceProfileError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateInstanceProfileError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateInstanceProfileError {}
#[derive(Debug, PartialEq)]
pub enum UpdateNetworkProfileError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl UpdateNetworkProfileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateNetworkProfileError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(UpdateNetworkProfileError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateNetworkProfileError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateNetworkProfileError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(UpdateNetworkProfileError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateNetworkProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateNetworkProfileError::Argument(ref cause) => write!(f, "{}", cause),
UpdateNetworkProfileError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateNetworkProfileError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateNetworkProfileError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateNetworkProfileError {}
#[derive(Debug, PartialEq)]
pub enum UpdateProjectError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl UpdateProjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateProjectError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(UpdateProjectError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateProjectError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateProjectError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(UpdateProjectError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateProjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateProjectError::Argument(ref cause) => write!(f, "{}", cause),
UpdateProjectError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateProjectError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateProjectError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateProjectError {}
#[derive(Debug, PartialEq)]
pub enum UpdateTestGridProjectError {
Argument(String),
InternalService(String),
NotFound(String),
}
impl UpdateTestGridProjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateTestGridProjectError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(UpdateTestGridProjectError::Argument(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(UpdateTestGridProjectError::InternalService(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(UpdateTestGridProjectError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateTestGridProjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateTestGridProjectError::Argument(ref cause) => write!(f, "{}", cause),
UpdateTestGridProjectError::InternalService(ref cause) => write!(f, "{}", cause),
UpdateTestGridProjectError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateTestGridProjectError {}
#[derive(Debug, PartialEq)]
pub enum UpdateUploadError {
Argument(String),
LimitExceeded(String),
NotFound(String),
ServiceAccount(String),
}
impl UpdateUploadError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateUploadError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(UpdateUploadError::Argument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateUploadError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateUploadError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(UpdateUploadError::ServiceAccount(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateUploadError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateUploadError::Argument(ref cause) => write!(f, "{}", cause),
UpdateUploadError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateUploadError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateUploadError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateUploadError {}
#[derive(Debug, PartialEq)]
pub enum UpdateVPCEConfigurationError {
Argument(String),
InvalidOperation(String),
NotFound(String),
ServiceAccount(String),
}
impl UpdateVPCEConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateVPCEConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArgumentException" => {
return RusotoError::Service(UpdateVPCEConfigurationError::Argument(err.msg))
}
"InvalidOperationException" => {
return RusotoError::Service(UpdateVPCEConfigurationError::InvalidOperation(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(UpdateVPCEConfigurationError::NotFound(err.msg))
}
"ServiceAccountException" => {
return RusotoError::Service(UpdateVPCEConfigurationError::ServiceAccount(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateVPCEConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateVPCEConfigurationError::Argument(ref cause) => write!(f, "{}", cause),
UpdateVPCEConfigurationError::InvalidOperation(ref cause) => write!(f, "{}", cause),
UpdateVPCEConfigurationError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateVPCEConfigurationError::ServiceAccount(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateVPCEConfigurationError {}
#[async_trait]
pub trait DeviceFarm {
async fn create_device_pool(
&self,
input: CreateDevicePoolRequest,
) -> Result<CreateDevicePoolResult, RusotoError<CreateDevicePoolError>>;
async fn create_instance_profile(
&self,
input: CreateInstanceProfileRequest,
) -> Result<CreateInstanceProfileResult, RusotoError<CreateInstanceProfileError>>;
async fn create_network_profile(
&self,
input: CreateNetworkProfileRequest,
) -> Result<CreateNetworkProfileResult, RusotoError<CreateNetworkProfileError>>;
async fn create_project(
&self,
input: CreateProjectRequest,
) -> Result<CreateProjectResult, RusotoError<CreateProjectError>>;
async fn create_remote_access_session(
&self,
input: CreateRemoteAccessSessionRequest,
) -> Result<CreateRemoteAccessSessionResult, RusotoError<CreateRemoteAccessSessionError>>;
async fn create_test_grid_project(
&self,
input: CreateTestGridProjectRequest,
) -> Result<CreateTestGridProjectResult, RusotoError<CreateTestGridProjectError>>;
async fn create_test_grid_url(
&self,
input: CreateTestGridUrlRequest,
) -> Result<CreateTestGridUrlResult, RusotoError<CreateTestGridUrlError>>;
async fn create_upload(
&self,
input: CreateUploadRequest,
) -> Result<CreateUploadResult, RusotoError<CreateUploadError>>;
async fn create_vpce_configuration(
&self,
input: CreateVPCEConfigurationRequest,
) -> Result<CreateVPCEConfigurationResult, RusotoError<CreateVPCEConfigurationError>>;
async fn delete_device_pool(
&self,
input: DeleteDevicePoolRequest,
) -> Result<DeleteDevicePoolResult, RusotoError<DeleteDevicePoolError>>;
async fn delete_instance_profile(
&self,
input: DeleteInstanceProfileRequest,
) -> Result<DeleteInstanceProfileResult, RusotoError<DeleteInstanceProfileError>>;
async fn delete_network_profile(
&self,
input: DeleteNetworkProfileRequest,
) -> Result<DeleteNetworkProfileResult, RusotoError<DeleteNetworkProfileError>>;
async fn delete_project(
&self,
input: DeleteProjectRequest,
) -> Result<DeleteProjectResult, RusotoError<DeleteProjectError>>;
async fn delete_remote_access_session(
&self,
input: DeleteRemoteAccessSessionRequest,
) -> Result<DeleteRemoteAccessSessionResult, RusotoError<DeleteRemoteAccessSessionError>>;
async fn delete_run(
&self,
input: DeleteRunRequest,
) -> Result<DeleteRunResult, RusotoError<DeleteRunError>>;
async fn delete_test_grid_project(
&self,
input: DeleteTestGridProjectRequest,
) -> Result<DeleteTestGridProjectResult, RusotoError<DeleteTestGridProjectError>>;
async fn delete_upload(
&self,
input: DeleteUploadRequest,
) -> Result<DeleteUploadResult, RusotoError<DeleteUploadError>>;
async fn delete_vpce_configuration(
&self,
input: DeleteVPCEConfigurationRequest,
) -> Result<DeleteVPCEConfigurationResult, RusotoError<DeleteVPCEConfigurationError>>;
async fn get_account_settings(
&self,
) -> Result<GetAccountSettingsResult, RusotoError<GetAccountSettingsError>>;
async fn get_device(
&self,
input: GetDeviceRequest,
) -> Result<GetDeviceResult, RusotoError<GetDeviceError>>;
async fn get_device_instance(
&self,
input: GetDeviceInstanceRequest,
) -> Result<GetDeviceInstanceResult, RusotoError<GetDeviceInstanceError>>;
async fn get_device_pool(
&self,
input: GetDevicePoolRequest,
) -> Result<GetDevicePoolResult, RusotoError<GetDevicePoolError>>;
async fn get_device_pool_compatibility(
&self,
input: GetDevicePoolCompatibilityRequest,
) -> Result<GetDevicePoolCompatibilityResult, RusotoError<GetDevicePoolCompatibilityError>>;
async fn get_instance_profile(
&self,
input: GetInstanceProfileRequest,
) -> Result<GetInstanceProfileResult, RusotoError<GetInstanceProfileError>>;
async fn get_job(&self, input: GetJobRequest)
-> Result<GetJobResult, RusotoError<GetJobError>>;
async fn get_network_profile(
&self,
input: GetNetworkProfileRequest,
) -> Result<GetNetworkProfileResult, RusotoError<GetNetworkProfileError>>;
async fn get_offering_status(
&self,
input: GetOfferingStatusRequest,
) -> Result<GetOfferingStatusResult, RusotoError<GetOfferingStatusError>>;
async fn get_project(
&self,
input: GetProjectRequest,
) -> Result<GetProjectResult, RusotoError<GetProjectError>>;
async fn get_remote_access_session(
&self,
input: GetRemoteAccessSessionRequest,
) -> Result<GetRemoteAccessSessionResult, RusotoError<GetRemoteAccessSessionError>>;
async fn get_run(&self, input: GetRunRequest)
-> Result<GetRunResult, RusotoError<GetRunError>>;
async fn get_suite(
&self,
input: GetSuiteRequest,
) -> Result<GetSuiteResult, RusotoError<GetSuiteError>>;
async fn get_test(
&self,
input: GetTestRequest,
) -> Result<GetTestResult, RusotoError<GetTestError>>;
async fn get_test_grid_project(
&self,
input: GetTestGridProjectRequest,
) -> Result<GetTestGridProjectResult, RusotoError<GetTestGridProjectError>>;
async fn get_test_grid_session(
&self,
input: GetTestGridSessionRequest,
) -> Result<GetTestGridSessionResult, RusotoError<GetTestGridSessionError>>;
async fn get_upload(
&self,
input: GetUploadRequest,
) -> Result<GetUploadResult, RusotoError<GetUploadError>>;
async fn get_vpce_configuration(
&self,
input: GetVPCEConfigurationRequest,
) -> Result<GetVPCEConfigurationResult, RusotoError<GetVPCEConfigurationError>>;
async fn install_to_remote_access_session(
&self,
input: InstallToRemoteAccessSessionRequest,
) -> Result<InstallToRemoteAccessSessionResult, RusotoError<InstallToRemoteAccessSessionError>>;
async fn list_artifacts(
&self,
input: ListArtifactsRequest,
) -> Result<ListArtifactsResult, RusotoError<ListArtifactsError>>;
async fn list_device_instances(
&self,
input: ListDeviceInstancesRequest,
) -> Result<ListDeviceInstancesResult, RusotoError<ListDeviceInstancesError>>;
async fn list_device_pools(
&self,
input: ListDevicePoolsRequest,
) -> Result<ListDevicePoolsResult, RusotoError<ListDevicePoolsError>>;
async fn list_devices(
&self,
input: ListDevicesRequest,
) -> Result<ListDevicesResult, RusotoError<ListDevicesError>>;
async fn list_instance_profiles(
&self,
input: ListInstanceProfilesRequest,
) -> Result<ListInstanceProfilesResult, RusotoError<ListInstanceProfilesError>>;
async fn list_jobs(
&self,
input: ListJobsRequest,
) -> Result<ListJobsResult, RusotoError<ListJobsError>>;
async fn list_network_profiles(
&self,
input: ListNetworkProfilesRequest,
) -> Result<ListNetworkProfilesResult, RusotoError<ListNetworkProfilesError>>;
async fn list_offering_promotions(
&self,
input: ListOfferingPromotionsRequest,
) -> Result<ListOfferingPromotionsResult, RusotoError<ListOfferingPromotionsError>>;
async fn list_offering_transactions(
&self,
input: ListOfferingTransactionsRequest,
) -> Result<ListOfferingTransactionsResult, RusotoError<ListOfferingTransactionsError>>;
async fn list_offerings(
&self,
input: ListOfferingsRequest,
) -> Result<ListOfferingsResult, RusotoError<ListOfferingsError>>;
async fn list_projects(
&self,
input: ListProjectsRequest,
) -> Result<ListProjectsResult, RusotoError<ListProjectsError>>;
async fn list_remote_access_sessions(
&self,
input: ListRemoteAccessSessionsRequest,
) -> Result<ListRemoteAccessSessionsResult, RusotoError<ListRemoteAccessSessionsError>>;
async fn list_runs(
&self,
input: ListRunsRequest,
) -> Result<ListRunsResult, RusotoError<ListRunsError>>;
async fn list_samples(
&self,
input: ListSamplesRequest,
) -> Result<ListSamplesResult, RusotoError<ListSamplesError>>;
async fn list_suites(
&self,
input: ListSuitesRequest,
) -> Result<ListSuitesResult, RusotoError<ListSuitesError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn list_test_grid_projects(
&self,
input: ListTestGridProjectsRequest,
) -> Result<ListTestGridProjectsResult, RusotoError<ListTestGridProjectsError>>;
async fn list_test_grid_session_actions(
&self,
input: ListTestGridSessionActionsRequest,
) -> Result<ListTestGridSessionActionsResult, RusotoError<ListTestGridSessionActionsError>>;
async fn list_test_grid_session_artifacts(
&self,
input: ListTestGridSessionArtifactsRequest,
) -> Result<ListTestGridSessionArtifactsResult, RusotoError<ListTestGridSessionArtifactsError>>;
async fn list_test_grid_sessions(
&self,
input: ListTestGridSessionsRequest,
) -> Result<ListTestGridSessionsResult, RusotoError<ListTestGridSessionsError>>;
async fn list_tests(
&self,
input: ListTestsRequest,
) -> Result<ListTestsResult, RusotoError<ListTestsError>>;
async fn list_unique_problems(
&self,
input: ListUniqueProblemsRequest,
) -> Result<ListUniqueProblemsResult, RusotoError<ListUniqueProblemsError>>;
async fn list_uploads(
&self,
input: ListUploadsRequest,
) -> Result<ListUploadsResult, RusotoError<ListUploadsError>>;
async fn list_vpce_configurations(
&self,
input: ListVPCEConfigurationsRequest,
) -> Result<ListVPCEConfigurationsResult, RusotoError<ListVPCEConfigurationsError>>;
async fn purchase_offering(
&self,
input: PurchaseOfferingRequest,
) -> Result<PurchaseOfferingResult, RusotoError<PurchaseOfferingError>>;
async fn renew_offering(
&self,
input: RenewOfferingRequest,
) -> Result<RenewOfferingResult, RusotoError<RenewOfferingError>>;
async fn schedule_run(
&self,
input: ScheduleRunRequest,
) -> Result<ScheduleRunResult, RusotoError<ScheduleRunError>>;
async fn stop_job(
&self,
input: StopJobRequest,
) -> Result<StopJobResult, RusotoError<StopJobError>>;
async fn stop_remote_access_session(
&self,
input: StopRemoteAccessSessionRequest,
) -> Result<StopRemoteAccessSessionResult, RusotoError<StopRemoteAccessSessionError>>;
async fn stop_run(
&self,
input: StopRunRequest,
) -> Result<StopRunResult, RusotoError<StopRunError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_device_instance(
&self,
input: UpdateDeviceInstanceRequest,
) -> Result<UpdateDeviceInstanceResult, RusotoError<UpdateDeviceInstanceError>>;
async fn update_device_pool(
&self,
input: UpdateDevicePoolRequest,
) -> Result<UpdateDevicePoolResult, RusotoError<UpdateDevicePoolError>>;
async fn update_instance_profile(
&self,
input: UpdateInstanceProfileRequest,
) -> Result<UpdateInstanceProfileResult, RusotoError<UpdateInstanceProfileError>>;
async fn update_network_profile(
&self,
input: UpdateNetworkProfileRequest,
) -> Result<UpdateNetworkProfileResult, RusotoError<UpdateNetworkProfileError>>;
async fn update_project(
&self,
input: UpdateProjectRequest,
) -> Result<UpdateProjectResult, RusotoError<UpdateProjectError>>;
async fn update_test_grid_project(
&self,
input: UpdateTestGridProjectRequest,
) -> Result<UpdateTestGridProjectResult, RusotoError<UpdateTestGridProjectError>>;
async fn update_upload(
&self,
input: UpdateUploadRequest,
) -> Result<UpdateUploadResult, RusotoError<UpdateUploadError>>;
async fn update_vpce_configuration(
&self,
input: UpdateVPCEConfigurationRequest,
) -> Result<UpdateVPCEConfigurationResult, RusotoError<UpdateVPCEConfigurationError>>;
}
#[derive(Clone)]
pub struct DeviceFarmClient {
client: Client,
region: region::Region,
}
impl DeviceFarmClient {
pub fn new(region: region::Region) -> DeviceFarmClient {
DeviceFarmClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> DeviceFarmClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
DeviceFarmClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> DeviceFarmClient {
DeviceFarmClient { client, region }
}
}
#[async_trait]
impl DeviceFarm for DeviceFarmClient {
async fn create_device_pool(
&self,
input: CreateDevicePoolRequest,
) -> Result<CreateDevicePoolResult, RusotoError<CreateDevicePoolError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.CreateDevicePool");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDevicePoolError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateDevicePoolResult, _>()
}
async fn create_instance_profile(
&self,
input: CreateInstanceProfileRequest,
) -> Result<CreateInstanceProfileResult, RusotoError<CreateInstanceProfileError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.CreateInstanceProfile");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateInstanceProfileError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateInstanceProfileResult, _>()
}
async fn create_network_profile(
&self,
input: CreateNetworkProfileRequest,
) -> Result<CreateNetworkProfileResult, RusotoError<CreateNetworkProfileError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.CreateNetworkProfile");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateNetworkProfileError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateNetworkProfileResult, _>()
}
async fn create_project(
&self,
input: CreateProjectRequest,
) -> Result<CreateProjectResult, RusotoError<CreateProjectError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.CreateProject");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateProjectError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateProjectResult, _>()
}
async fn create_remote_access_session(
&self,
input: CreateRemoteAccessSessionRequest,
) -> Result<CreateRemoteAccessSessionResult, RusotoError<CreateRemoteAccessSessionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DeviceFarm_20150623.CreateRemoteAccessSession",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateRemoteAccessSessionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateRemoteAccessSessionResult, _>()
}
async fn create_test_grid_project(
&self,
input: CreateTestGridProjectRequest,
) -> Result<CreateTestGridProjectResult, RusotoError<CreateTestGridProjectError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.CreateTestGridProject");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateTestGridProjectError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateTestGridProjectResult, _>()
}
async fn create_test_grid_url(
&self,
input: CreateTestGridUrlRequest,
) -> Result<CreateTestGridUrlResult, RusotoError<CreateTestGridUrlError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.CreateTestGridUrl");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateTestGridUrlError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateTestGridUrlResult, _>()
}
async fn create_upload(
&self,
input: CreateUploadRequest,
) -> Result<CreateUploadResult, RusotoError<CreateUploadError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.CreateUpload");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateUploadError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateUploadResult, _>()
}
async fn create_vpce_configuration(
&self,
input: CreateVPCEConfigurationRequest,
) -> Result<CreateVPCEConfigurationResult, RusotoError<CreateVPCEConfigurationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DeviceFarm_20150623.CreateVPCEConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateVPCEConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateVPCEConfigurationResult, _>()
}
async fn delete_device_pool(
&self,
input: DeleteDevicePoolRequest,
) -> Result<DeleteDevicePoolResult, RusotoError<DeleteDevicePoolError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.DeleteDevicePool");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteDevicePoolError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteDevicePoolResult, _>()
}
async fn delete_instance_profile(
&self,
input: DeleteInstanceProfileRequest,
) -> Result<DeleteInstanceProfileResult, RusotoError<DeleteInstanceProfileError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.DeleteInstanceProfile");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteInstanceProfileError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteInstanceProfileResult, _>()
}
async fn delete_network_profile(
&self,
input: DeleteNetworkProfileRequest,
) -> Result<DeleteNetworkProfileResult, RusotoError<DeleteNetworkProfileError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.DeleteNetworkProfile");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteNetworkProfileError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteNetworkProfileResult, _>()
}
async fn delete_project(
&self,
input: DeleteProjectRequest,
) -> Result<DeleteProjectResult, RusotoError<DeleteProjectError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.DeleteProject");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteProjectError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteProjectResult, _>()
}
async fn delete_remote_access_session(
&self,
input: DeleteRemoteAccessSessionRequest,
) -> Result<DeleteRemoteAccessSessionResult, RusotoError<DeleteRemoteAccessSessionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DeviceFarm_20150623.DeleteRemoteAccessSession",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteRemoteAccessSessionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteRemoteAccessSessionResult, _>()
}
async fn delete_run(
&self,
input: DeleteRunRequest,
) -> Result<DeleteRunResult, RusotoError<DeleteRunError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.DeleteRun");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteRunError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteRunResult, _>()
}
async fn delete_test_grid_project(
&self,
input: DeleteTestGridProjectRequest,
) -> Result<DeleteTestGridProjectResult, RusotoError<DeleteTestGridProjectError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.DeleteTestGridProject");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteTestGridProjectError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteTestGridProjectResult, _>()
}
async fn delete_upload(
&self,
input: DeleteUploadRequest,
) -> Result<DeleteUploadResult, RusotoError<DeleteUploadError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.DeleteUpload");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteUploadError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteUploadResult, _>()
}
async fn delete_vpce_configuration(
&self,
input: DeleteVPCEConfigurationRequest,
) -> Result<DeleteVPCEConfigurationResult, RusotoError<DeleteVPCEConfigurationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DeviceFarm_20150623.DeleteVPCEConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteVPCEConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteVPCEConfigurationResult, _>()
}
async fn get_account_settings(
&self,
) -> Result<GetAccountSettingsResult, RusotoError<GetAccountSettingsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetAccountSettings");
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, GetAccountSettingsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetAccountSettingsResult, _>()
}
async fn get_device(
&self,
input: GetDeviceRequest,
) -> Result<GetDeviceResult, RusotoError<GetDeviceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetDevice");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDeviceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDeviceResult, _>()
}
async fn get_device_instance(
&self,
input: GetDeviceInstanceRequest,
) -> Result<GetDeviceInstanceResult, RusotoError<GetDeviceInstanceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetDeviceInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDeviceInstanceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDeviceInstanceResult, _>()
}
async fn get_device_pool(
&self,
input: GetDevicePoolRequest,
) -> Result<GetDevicePoolResult, RusotoError<GetDevicePoolError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetDevicePool");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDevicePoolError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDevicePoolResult, _>()
}
async fn get_device_pool_compatibility(
&self,
input: GetDevicePoolCompatibilityRequest,
) -> Result<GetDevicePoolCompatibilityResult, RusotoError<GetDevicePoolCompatibilityError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DeviceFarm_20150623.GetDevicePoolCompatibility",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDevicePoolCompatibilityError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetDevicePoolCompatibilityResult, _>()
}
async fn get_instance_profile(
&self,
input: GetInstanceProfileRequest,
) -> Result<GetInstanceProfileResult, RusotoError<GetInstanceProfileError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetInstanceProfile");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetInstanceProfileError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetInstanceProfileResult, _>()
}
async fn get_job(
&self,
input: GetJobRequest,
) -> Result<GetJobResult, RusotoError<GetJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetJob");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetJobResult, _>()
}
async fn get_network_profile(
&self,
input: GetNetworkProfileRequest,
) -> Result<GetNetworkProfileResult, RusotoError<GetNetworkProfileError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetNetworkProfile");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetNetworkProfileError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetNetworkProfileResult, _>()
}
async fn get_offering_status(
&self,
input: GetOfferingStatusRequest,
) -> Result<GetOfferingStatusResult, RusotoError<GetOfferingStatusError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetOfferingStatus");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetOfferingStatusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetOfferingStatusResult, _>()
}
async fn get_project(
&self,
input: GetProjectRequest,
) -> Result<GetProjectResult, RusotoError<GetProjectError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetProject");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetProjectError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetProjectResult, _>()
}
async fn get_remote_access_session(
&self,
input: GetRemoteAccessSessionRequest,
) -> Result<GetRemoteAccessSessionResult, RusotoError<GetRemoteAccessSessionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetRemoteAccessSession");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRemoteAccessSessionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetRemoteAccessSessionResult, _>()
}
async fn get_run(
&self,
input: GetRunRequest,
) -> Result<GetRunResult, RusotoError<GetRunError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetRun");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRunError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetRunResult, _>()
}
async fn get_suite(
&self,
input: GetSuiteRequest,
) -> Result<GetSuiteResult, RusotoError<GetSuiteError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetSuite");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetSuiteError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetSuiteResult, _>()
}
async fn get_test(
&self,
input: GetTestRequest,
) -> Result<GetTestResult, RusotoError<GetTestError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetTest");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetTestError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetTestResult, _>()
}
async fn get_test_grid_project(
&self,
input: GetTestGridProjectRequest,
) -> Result<GetTestGridProjectResult, RusotoError<GetTestGridProjectError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetTestGridProject");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetTestGridProjectError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetTestGridProjectResult, _>()
}
async fn get_test_grid_session(
&self,
input: GetTestGridSessionRequest,
) -> Result<GetTestGridSessionResult, RusotoError<GetTestGridSessionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetTestGridSession");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetTestGridSessionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetTestGridSessionResult, _>()
}
async fn get_upload(
&self,
input: GetUploadRequest,
) -> Result<GetUploadResult, RusotoError<GetUploadError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetUpload");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetUploadError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetUploadResult, _>()
}
async fn get_vpce_configuration(
&self,
input: GetVPCEConfigurationRequest,
) -> Result<GetVPCEConfigurationResult, RusotoError<GetVPCEConfigurationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.GetVPCEConfiguration");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetVPCEConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetVPCEConfigurationResult, _>()
}
async fn install_to_remote_access_session(
&self,
input: InstallToRemoteAccessSessionRequest,
) -> Result<InstallToRemoteAccessSessionResult, RusotoError<InstallToRemoteAccessSessionError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DeviceFarm_20150623.InstallToRemoteAccessSession",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, InstallToRemoteAccessSessionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<InstallToRemoteAccessSessionResult, _>()
}
async fn list_artifacts(
&self,
input: ListArtifactsRequest,
) -> Result<ListArtifactsResult, RusotoError<ListArtifactsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListArtifacts");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListArtifactsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListArtifactsResult, _>()
}
async fn list_device_instances(
&self,
input: ListDeviceInstancesRequest,
) -> Result<ListDeviceInstancesResult, RusotoError<ListDeviceInstancesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListDeviceInstances");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDeviceInstancesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListDeviceInstancesResult, _>()
}
async fn list_device_pools(
&self,
input: ListDevicePoolsRequest,
) -> Result<ListDevicePoolsResult, RusotoError<ListDevicePoolsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListDevicePools");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDevicePoolsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListDevicePoolsResult, _>()
}
async fn list_devices(
&self,
input: ListDevicesRequest,
) -> Result<ListDevicesResult, RusotoError<ListDevicesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListDevices");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDevicesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListDevicesResult, _>()
}
async fn list_instance_profiles(
&self,
input: ListInstanceProfilesRequest,
) -> Result<ListInstanceProfilesResult, RusotoError<ListInstanceProfilesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListInstanceProfiles");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListInstanceProfilesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListInstanceProfilesResult, _>()
}
async fn list_jobs(
&self,
input: ListJobsRequest,
) -> Result<ListJobsResult, RusotoError<ListJobsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListJobs");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListJobsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListJobsResult, _>()
}
async fn list_network_profiles(
&self,
input: ListNetworkProfilesRequest,
) -> Result<ListNetworkProfilesResult, RusotoError<ListNetworkProfilesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListNetworkProfiles");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListNetworkProfilesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListNetworkProfilesResult, _>()
}
async fn list_offering_promotions(
&self,
input: ListOfferingPromotionsRequest,
) -> Result<ListOfferingPromotionsResult, RusotoError<ListOfferingPromotionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListOfferingPromotions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListOfferingPromotionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListOfferingPromotionsResult, _>()
}
async fn list_offering_transactions(
&self,
input: ListOfferingTransactionsRequest,
) -> Result<ListOfferingTransactionsResult, RusotoError<ListOfferingTransactionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DeviceFarm_20150623.ListOfferingTransactions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListOfferingTransactionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListOfferingTransactionsResult, _>()
}
async fn list_offerings(
&self,
input: ListOfferingsRequest,
) -> Result<ListOfferingsResult, RusotoError<ListOfferingsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListOfferings");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListOfferingsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListOfferingsResult, _>()
}
async fn list_projects(
&self,
input: ListProjectsRequest,
) -> Result<ListProjectsResult, RusotoError<ListProjectsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListProjects");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListProjectsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListProjectsResult, _>()
}
async fn list_remote_access_sessions(
&self,
input: ListRemoteAccessSessionsRequest,
) -> Result<ListRemoteAccessSessionsResult, RusotoError<ListRemoteAccessSessionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DeviceFarm_20150623.ListRemoteAccessSessions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListRemoteAccessSessionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListRemoteAccessSessionsResult, _>()
}
async fn list_runs(
&self,
input: ListRunsRequest,
) -> Result<ListRunsResult, RusotoError<ListRunsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListRuns");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListRunsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListRunsResult, _>()
}
async fn list_samples(
&self,
input: ListSamplesRequest,
) -> Result<ListSamplesResult, RusotoError<ListSamplesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListSamples");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListSamplesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListSamplesResult, _>()
}
async fn list_suites(
&self,
input: ListSuitesRequest,
) -> Result<ListSuitesResult, RusotoError<ListSuitesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListSuites");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListSuitesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListSuitesResult, _>()
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListTagsForResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTagsForResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTagsForResourceResponse, _>()
}
async fn list_test_grid_projects(
&self,
input: ListTestGridProjectsRequest,
) -> Result<ListTestGridProjectsResult, RusotoError<ListTestGridProjectsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListTestGridProjects");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTestGridProjectsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTestGridProjectsResult, _>()
}
async fn list_test_grid_session_actions(
&self,
input: ListTestGridSessionActionsRequest,
) -> Result<ListTestGridSessionActionsResult, RusotoError<ListTestGridSessionActionsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DeviceFarm_20150623.ListTestGridSessionActions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTestGridSessionActionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListTestGridSessionActionsResult, _>()
}
async fn list_test_grid_session_artifacts(
&self,
input: ListTestGridSessionArtifactsRequest,
) -> Result<ListTestGridSessionArtifactsResult, RusotoError<ListTestGridSessionArtifactsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DeviceFarm_20150623.ListTestGridSessionArtifacts",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTestGridSessionArtifactsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListTestGridSessionArtifactsResult, _>()
}
async fn list_test_grid_sessions(
&self,
input: ListTestGridSessionsRequest,
) -> Result<ListTestGridSessionsResult, RusotoError<ListTestGridSessionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListTestGridSessions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTestGridSessionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTestGridSessionsResult, _>()
}
async fn list_tests(
&self,
input: ListTestsRequest,
) -> Result<ListTestsResult, RusotoError<ListTestsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListTests");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTestsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTestsResult, _>()
}
async fn list_unique_problems(
&self,
input: ListUniqueProblemsRequest,
) -> Result<ListUniqueProblemsResult, RusotoError<ListUniqueProblemsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListUniqueProblems");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListUniqueProblemsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListUniqueProblemsResult, _>()
}
async fn list_uploads(
&self,
input: ListUploadsRequest,
) -> Result<ListUploadsResult, RusotoError<ListUploadsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListUploads");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListUploadsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListUploadsResult, _>()
}
async fn list_vpce_configurations(
&self,
input: ListVPCEConfigurationsRequest,
) -> Result<ListVPCEConfigurationsResult, RusotoError<ListVPCEConfigurationsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ListVPCEConfigurations");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListVPCEConfigurationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListVPCEConfigurationsResult, _>()
}
async fn purchase_offering(
&self,
input: PurchaseOfferingRequest,
) -> Result<PurchaseOfferingResult, RusotoError<PurchaseOfferingError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.PurchaseOffering");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PurchaseOfferingError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<PurchaseOfferingResult, _>()
}
async fn renew_offering(
&self,
input: RenewOfferingRequest,
) -> Result<RenewOfferingResult, RusotoError<RenewOfferingError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.RenewOffering");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RenewOfferingError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<RenewOfferingResult, _>()
}
async fn schedule_run(
&self,
input: ScheduleRunRequest,
) -> Result<ScheduleRunResult, RusotoError<ScheduleRunError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.ScheduleRun");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ScheduleRunError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ScheduleRunResult, _>()
}
async fn stop_job(
&self,
input: StopJobRequest,
) -> Result<StopJobResult, RusotoError<StopJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.StopJob");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StopJobResult, _>()
}
async fn stop_remote_access_session(
&self,
input: StopRemoteAccessSessionRequest,
) -> Result<StopRemoteAccessSessionResult, RusotoError<StopRemoteAccessSessionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DeviceFarm_20150623.StopRemoteAccessSession",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopRemoteAccessSessionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StopRemoteAccessSessionResult, _>()
}
async fn stop_run(
&self,
input: StopRunRequest,
) -> Result<StopRunResult, RusotoError<StopRunError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.StopRun");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopRunError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StopRunResult, _>()
}
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.TagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TagResourceResponse, _>()
}
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.UntagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UntagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UntagResourceResponse, _>()
}
async fn update_device_instance(
&self,
input: UpdateDeviceInstanceRequest,
) -> Result<UpdateDeviceInstanceResult, RusotoError<UpdateDeviceInstanceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.UpdateDeviceInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateDeviceInstanceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateDeviceInstanceResult, _>()
}
async fn update_device_pool(
&self,
input: UpdateDevicePoolRequest,
) -> Result<UpdateDevicePoolResult, RusotoError<UpdateDevicePoolError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.UpdateDevicePool");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateDevicePoolError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateDevicePoolResult, _>()
}
async fn update_instance_profile(
&self,
input: UpdateInstanceProfileRequest,
) -> Result<UpdateInstanceProfileResult, RusotoError<UpdateInstanceProfileError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.UpdateInstanceProfile");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateInstanceProfileError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateInstanceProfileResult, _>()
}
async fn update_network_profile(
&self,
input: UpdateNetworkProfileRequest,
) -> Result<UpdateNetworkProfileResult, RusotoError<UpdateNetworkProfileError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.UpdateNetworkProfile");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateNetworkProfileError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateNetworkProfileResult, _>()
}
async fn update_project(
&self,
input: UpdateProjectRequest,
) -> Result<UpdateProjectResult, RusotoError<UpdateProjectError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.UpdateProject");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateProjectError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateProjectResult, _>()
}
async fn update_test_grid_project(
&self,
input: UpdateTestGridProjectRequest,
) -> Result<UpdateTestGridProjectResult, RusotoError<UpdateTestGridProjectError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.UpdateTestGridProject");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateTestGridProjectError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateTestGridProjectResult, _>()
}
async fn update_upload(
&self,
input: UpdateUploadRequest,
) -> Result<UpdateUploadResult, RusotoError<UpdateUploadError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DeviceFarm_20150623.UpdateUpload");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateUploadError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateUploadResult, _>()
}
async fn update_vpce_configuration(
&self,
input: UpdateVPCEConfigurationRequest,
) -> Result<UpdateVPCEConfigurationResult, RusotoError<UpdateVPCEConfigurationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DeviceFarm_20150623.UpdateVPCEConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateVPCEConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateVPCEConfigurationResult, _>()
}
}